@useairfoil/producer-stripe 0.0.2 → 0.0.3

package/dist/{src-DXjXItdQ.mjs → src-DXKdOBgM.mjs}

@@ -91,7 +91,6 @@ const layer$1 = (config) => Layer.effect(StripeClient)(make$1(config)).pipe(Laye
 const layerConfig$1 = (config) => Layer.effect(StripeClient)(Config.unwrap(config).pipe(Effect.flatMap(make$1))).pipe(Layer.provide(RateLimiterLive));
 //#endregion
 //#region src/schemas/shared.ts
-const field = (fieldId, description) => Iceberg.field(fieldId, { description });
 const UnixTime = Schema.Int.pipe(Schema.decodeTo(Schema.Date, SchemaTransformation.transform({
 	decode: (seconds) => /* @__PURE__ */ new Date(seconds * 1e3),
 	encode: (date) => Math.floor(date.getTime() / 1e3)
@@ -100,81 +99,75 @@ const Long = Schema.Int.pipe(Schema.decodeTo(Schema.BigInt, SchemaTransformation
 	decode: (value) => BigInt(value),
 	encode: (value) => Number(value)
 })));
-const Metadata = Schema.NullOr(Schema.Record(Schema.String, Schema.String)).pipe(Schema.decodeTo(Schema.ReadonlyMap(Schema.String.annotate({
-	fieldId: 200,
-	description: "Metadata key."
-}), Schema.String.annotate({
-	fieldId: 201,
-	description: "Metadata value."
-})), SchemaTransformation.transform({
+const Metadata = Schema.NullOr(Schema.Record(Schema.String, Schema.String)).pipe(Schema.decodeTo(Schema.ReadonlyMap(Schema.String.annotate({ description: "Metadata key." }), Schema.String.annotate({ description: "Metadata value." })), SchemaTransformation.transform({
 	decode: (record) => new Map(Object.entries(record ?? {})),
 	encode: (map) => Object.fromEntries(map)
 })));
-const address = (baseId) => Schema.Struct({
-	line1: Schema.NullOr(Schema.String).pipe(field(baseId, "First address line.")),
-	line2: Schema.NullOr(Schema.String).pipe(field(baseId + 1, "Second address line.")),
-	city: Schema.NullOr(Schema.String).pipe(field(baseId + 2, "City.")),
-	state: Schema.NullOr(Schema.String).pipe(field(baseId + 3, "State, county, or region.")),
-	postal_code: Schema.NullOr(Schema.String).pipe(field(baseId + 4, "Postal code.")),
-	country: Schema.NullOr(Schema.String).pipe(field(baseId + 5, "Two-letter country code."))
+const address = Schema.Struct({
+	line1: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "First address line." })),
+	line2: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Second address line." })),
+	city: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "City." })),
+	state: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "State, county, or region." })),
+	postal_code: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Postal code." })),
+	country: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Two-letter country code." }))
 });
-const shipping = (baseId) => Schema.Struct({
-	name: Schema.String.pipe(field(baseId, "Recipient name.")),
-	phone: Schema.NullOr(Schema.String).pipe(field(baseId + 1, "Recipient phone number.")),
-	address: address(baseId + 3).pipe(field(baseId + 2, "Shipping address."))
+const shipping = Schema.Struct({
+	name: Schema.String.pipe(Schema.annotateKey({ description: "Recipient name." })),
+	phone: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Recipient phone number." })),
+	address: address.pipe(Schema.annotateKey({ description: "Shipping address." }))
 });
-const version = (fieldId) => Schema.Date.pipe(field(fieldId, "Time the row was fetched from Stripe."));
-const deleted = (fieldId) => Schema.optional(Schema.Boolean).pipe(field(fieldId, "Whether the object was deleted in Stripe."));
+const version = Schema.Date.pipe(Schema.annotateKey({ description: "Time the row was fetched from Stripe." }));
+const deleted = Schema.optional(Schema.Boolean).pipe(Schema.annotateKey({ description: "Whether the object was deleted in Stripe." }));
 //#endregion
 //#region src/schemas/charges.ts
 const ChargeSchema = Schema.Struct({
-	id: Schema.String.pipe(field(1, "Unique charge identifier.")),
-	version: version(2),
-	created: UnixTime.pipe(field(3, "Time when the charge was created.")),
-	livemode: Schema.Boolean.pipe(field(4, "Whether the charge exists in live mode.")),
-	amount: Long.pipe(field(5, "Amount to collect, in the smallest currency unit.")),
-	amount_captured: Long.pipe(field(6, "Amount captured.")),
-	amount_refunded: Long.pipe(field(7, "Amount refunded.")),
-	currency: Schema.String.pipe(field(8, "Three-letter currency code, in lowercase.")),
-	status: Schema.String.pipe(field(9, "Status: succeeded, pending, or failed.")),
-	paid: Schema.Boolean.pipe(field(10, "Whether the charge succeeded or was authorized.")),
-	captured: Schema.Boolean.pipe(field(11, "Whether the charge was captured.")),
-	refunded: Schema.Boolean.pipe(field(12, "Whether the charge was fully refunded.")),
-	disputed: Schema.Boolean.pipe(field(13, "Whether the charge was disputed.")),
-	customer: Schema.NullOr(Schema.String).pipe(field(14, "Customer who was charged, if any.")),
-	payment_intent: Schema.NullOr(Schema.String).pipe(field(15, "Payment intent of the charge.")),
-	payment_method: Schema.NullOr(Schema.String).pipe(field(16, "Payment method used.")),
-	balance_transaction: Schema.NullOr(Schema.String).pipe(field(17, "Balance transaction for the charge.")),
-	description: Schema.NullOr(Schema.String).pipe(field(18, "Free-text description.")),
-	failure_code: Schema.NullOr(Schema.String).pipe(field(19, "Error code for failed charges.")),
-	failure_message: Schema.NullOr(Schema.String).pipe(field(20, "Error message for failed charges.")),
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique charge identifier." })),
+	version,
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the charge was created." })),
+	livemode: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the charge exists in live mode." })),
+	amount: Long.pipe(Schema.annotateKey({ description: "Amount to collect, in the smallest currency unit." })),
+	amount_captured: Long.pipe(Schema.annotateKey({ description: "Amount captured." })),
+	amount_refunded: Long.pipe(Schema.annotateKey({ description: "Amount refunded." })),
+	currency: Schema.String.pipe(Schema.annotateKey({ description: "Three-letter currency code, in lowercase." })),
+	status: Schema.String.pipe(Schema.annotateKey({ description: "Status: succeeded, pending, or failed." })),
+	paid: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the charge succeeded or was authorized." })),
+	captured: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the charge was captured." })),
+	refunded: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the charge was fully refunded." })),
+	disputed: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the charge was disputed." })),
+	customer: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer who was charged, if any." })),
+	payment_intent: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Payment intent of the charge." })),
+	payment_method: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Payment method used." })),
+	balance_transaction: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Balance transaction for the charge." })),
+	description: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Free-text description." })),
+	failure_code: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Error code for failed charges." })),
+	failure_message: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Error message for failed charges." })),
 	payment_method_details: Schema.NullOr(Schema.Struct({
-		type: Schema.String.pipe(field(100, "Payment method type, such as card.")),
+		type: Schema.String.pipe(Schema.annotateKey({ description: "Payment method type, such as card." })),
 		card: Schema.optional(Schema.NullOr(Schema.Struct({
-			brand: Schema.NullOr(Schema.String).pipe(field(102, "Card brand.")),
-			country: Schema.NullOr(Schema.String).pipe(field(103, "Two-letter card country.")),
-			funding: Schema.NullOr(Schema.String).pipe(field(104, "Funding type: credit, debit, prepaid, or unknown.")),
-			last4: Schema.NullOr(Schema.String).pipe(field(105, "Last four card digits.")),
-			exp_month: Long.pipe(field(106, "Expiry month.")),
-			exp_year: Long.pipe(field(107, "Expiry year.")),
-			fingerprint: Schema.optional(Schema.NullOr(Schema.String)).pipe(field(108, "Stripe's fingerprint of the card number, for finding duplicates."))
-		}))).pipe(field(101, "Card details. Only set for card payments."))
-	})).pipe(field(21, "Payment method details at the time of the charge.")),
+			brand: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Card brand." })),
+			country: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Two-letter card country." })),
+			funding: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Funding type: credit, debit, prepaid, or unknown." })),
+			last4: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Last four card digits." })),
+			exp_month: Long.pipe(Schema.annotateKey({ description: "Expiry month." })),
+			exp_year: Long.pipe(Schema.annotateKey({ description: "Expiry year." })),
+			fingerprint: Schema.optional(Schema.NullOr(Schema.String)).pipe(Schema.annotateKey({ description: "Stripe's fingerprint of the card number, for finding duplicates." }))
+		}))).pipe(Schema.annotateKey({ description: "Card details. Only set for card payments." }))
+	})).pipe(Schema.annotateKey({ description: "Payment method details at the time of the charge." })),
 	outcome: Schema.NullOr(Schema.Struct({
-		type: Schema.String.pipe(field(110, "Outcome type, such as authorized or issuer_declined.")),
-		network_status: Schema.NullOr(Schema.String).pipe(field(111, "Card network result.")),
-		reason: Schema.NullOr(Schema.String).pipe(field(112, "Reason for a decline or block.")),
-		risk_level: Schema.optional(Schema.NullOr(Schema.String)).pipe(field(113, "Radar risk level.")),
-		seller_message: Schema.NullOr(Schema.String).pipe(field(114, "Explanation of the outcome for the seller."))
-	})).pipe(field(22, "Whether the payment was accepted, and why.")),
-	metadata: Metadata.pipe(field(23, "Key-value pairs set on the charge.")),
+		type: Schema.String.pipe(Schema.annotateKey({ description: "Outcome type, such as authorized or issuer_declined." })),
+		network_status: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Card network result." })),
+		reason: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Reason for a decline or block." })),
+		risk_level: Schema.optional(Schema.NullOr(Schema.String)).pipe(Schema.annotateKey({ description: "Radar risk level." })),
+		seller_message: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Explanation of the outcome for the seller." }))
+	})).pipe(Schema.annotateKey({ description: "Whether the payment was accepted, and why." })),
+	metadata: Metadata.pipe(Schema.annotateKey({ description: "Key-value pairs set on the charge." })),
 	billing_details: Schema.Struct({
-		name: Schema.NullOr(Schema.String).pipe(field(140, "Payer name.")),
-		email: Schema.NullOr(Schema.String).pipe(field(141, "Payer email.")),
-		phone: Schema.NullOr(Schema.String).pipe(field(142, "Payer phone number.")),
-		address: Schema.NullOr(address(144)).pipe(field(143, "Billing address."))
-	}).pipe(field(24, "Billing details of the payment method at the time of the charge.")),
-	receipt_email: Schema.NullOr(Schema.String).pipe(field(25, "Email the receipt was sent to."))
+		name: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Payer name." })),
+		email: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Payer email." })),
+		phone: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Payer phone number." })),
+		address: Schema.NullOr(address).pipe(Schema.annotateKey({ description: "Billing address." }))
+	}).pipe(Schema.annotateKey({ description: "Billing details of the payment method at the time of the charge." })),
+	receipt_email: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Email the receipt was sent to." }))
 }).annotate({ description: "Charges in a Stripe account." }).pipe(Iceberg.identifier("id"));
 const ChargeObjectSchema = ChargeSchema.mapFields(Struct.omit(["version"]));
 //#endregion
@@ -367,25 +360,25 @@ const makeCharges = (client) => Resource.entity({
 //#endregion
 //#region src/schemas/customers.ts
 const CustomerSchema = Schema.Struct({
-	id: Schema.String.pipe(field(1, "Unique customer identifier.")),
-	version: version(2),
-	created: UnixTime.pipe(field(3, "Time when the customer was created.")),
-	livemode: Schema.Boolean.pipe(field(4, "Whether the customer exists in live mode.")),
-	email: Schema.NullOr(Schema.String).pipe(field(5, "Customer email address.")),
-	name: Schema.NullOr(Schema.String).pipe(field(6, "Customer full name or business name.")),
-	phone: Schema.NullOr(Schema.String).pipe(field(7, "Customer phone number.")),
-	description: Schema.NullOr(Schema.String).pipe(field(8, "Free-text description.")),
-	currency: Schema.NullOr(Schema.String).pipe(field(9, "Currency the customer is billed in for recurring billing.")),
-	balance: Long.pipe(field(10, "Balance in the smallest currency unit. Negative means credit, positive means owed.")),
-	delinquent: Schema.NullOr(Schema.Boolean).pipe(field(11, "Whether the latest invoice state change was a failed payment or missed due date.")),
-	tax_exempt: Schema.NullOr(Schema.String).pipe(field(12, "Tax exemption status: none, exempt, or reverse.")),
-	invoice_prefix: Schema.NullOr(Schema.String).pipe(field(13, "Prefix for invoice numbers.")),
-	invoice_settings: Schema.Struct({ default_payment_method: Schema.NullOr(Schema.String).pipe(field(106, "Default payment method for invoices and subscriptions.")) }).pipe(field(14, "Default invoice settings.")),
-	address: Schema.NullOr(address(100)).pipe(field(15, "Billing address.")),
-	metadata: Metadata.pipe(field(16, "Key-value pairs set on the customer.")),
-	_deleted: deleted(17),
-	test_clock: Schema.NullOr(Schema.String).pipe(field(18, "Test clock the customer belongs to. Sandbox only.")),
-	shipping: Schema.NullOr(shipping(110)).pipe(field(19, "Shipping name, phone, and address."))
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique customer identifier." })),
+	version,
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the customer was created." })),
+	livemode: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the customer exists in live mode." })),
+	email: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer email address." })),
+	name: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer full name or business name." })),
+	phone: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer phone number." })),
+	description: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Free-text description." })),
+	currency: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Currency the customer is billed in for recurring billing." })),
+	balance: Long.pipe(Schema.annotateKey({ description: "Balance in the smallest currency unit. Negative means credit, positive means owed." })),
+	delinquent: Schema.NullOr(Schema.Boolean).pipe(Schema.annotateKey({ description: "Whether the latest invoice state change was a failed payment or missed due date." })),
+	tax_exempt: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Tax exemption status: none, exempt, or reverse." })),
+	invoice_prefix: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Prefix for invoice numbers." })),
+	invoice_settings: Schema.Struct({ default_payment_method: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Default payment method for invoices and subscriptions." })) }).pipe(Schema.annotateKey({ description: "Default invoice settings." })),
+	address: Schema.NullOr(address).pipe(Schema.annotateKey({ description: "Billing address." })),
+	metadata: Metadata.pipe(Schema.annotateKey({ description: "Key-value pairs set on the customer." })),
+	_deleted: deleted,
+	test_clock: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Test clock the customer belongs to. Sandbox only." })),
+	shipping: Schema.NullOr(shipping).pipe(Schema.annotateKey({ description: "Shipping name, phone, and address." }))
 }).annotate({ description: "Customers in a Stripe account." }).pipe(Iceberg.identifier("id"));
 const CustomerObjectSchema = CustomerSchema.mapFields(Struct.omit(["version", "_deleted"]));
 //#endregion
@@ -412,47 +405,47 @@ const makeCustomers = (client) => Resource.entity({
 //#endregion
 //#region src/schemas/invoices.ts
 const InvoiceSchema = Schema.Struct({
-	id: Schema.String.pipe(field(1, "Unique invoice identifier.")),
-	version: version(2),
-	created: UnixTime.pipe(field(3, "Time when the invoice was created.")),
-	livemode: Schema.Boolean.pipe(field(4, "Whether the invoice exists in live mode.")),
-	customer: Schema.NullOr(Schema.String).pipe(field(5, "Customer who is billed.")),
-	customer_account: Schema.NullOr(Schema.String).pipe(field(6, "Account that represents the customer, for Accounts v2.")),
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique invoice identifier." })),
+	version,
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the invoice was created." })),
+	livemode: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the invoice exists in live mode." })),
+	customer: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer who is billed." })),
+	customer_account: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Account that represents the customer, for Accounts v2." })),
 	parent: Schema.NullOr(Schema.Struct({
-		type: Schema.String.pipe(field(100, "What created the invoice, such as subscription_details.")),
-		subscription_details: Schema.NullOr(Schema.Struct({ subscription: Schema.String.pipe(field(102, "Subscription that created the invoice.")) })).pipe(field(101, "Set when a subscription created the invoice."))
-	})).pipe(field(7, "Object that created the invoice.")),
-	status: Schema.NullOr(Schema.String).pipe(field(8, "Status: draft, open, paid, uncollectible, or void.")),
-	number: Schema.NullOr(Schema.String).pipe(field(9, "Invoice number shown to the customer.")),
-	currency: Schema.String.pipe(field(10, "Three-letter currency code, in lowercase.")),
-	subtotal: Long.pipe(field(11, "Total before invoice-level discounts and exclusive tax.")),
-	total: Long.pipe(field(12, "Total after discounts and taxes.")),
-	total_excluding_tax: Schema.NullOr(Long).pipe(field(13, "Total after discounts, without tax.")),
-	amount_due: Long.pipe(field(14, "Amount due now.")),
-	amount_paid: Long.pipe(field(15, "Amount paid.")),
-	amount_remaining: Long.pipe(field(16, "Amount due minus amount paid.")),
-	amount_overpaid: Long.pipe(field(17, "Overpaid amount, credited to the customer balance.")),
-	attempt_count: Long.pipe(field(18, "Payment attempts made by the retry schedule.")),
-	billing_reason: Schema.NullOr(Schema.String).pipe(field(19, "Why the invoice was created.")),
-	collection_method: Schema.String.pipe(field(20, "How the invoice is paid: charge_automatically or send_invoice.")),
-	due_date: Schema.NullOr(UnixTime).pipe(field(21, "Due date. Only set for send_invoice.")),
-	period_start: UnixTime.pipe(field(22, "Earliest time items can belong to the invoice.")),
-	period_end: UnixTime.pipe(field(23, "Latest time items can belong to the invoice.")),
-	effective_at: Schema.NullOr(UnixTime).pipe(field(24, "Date of issue.")),
+		type: Schema.String.pipe(Schema.annotateKey({ description: "What created the invoice, such as subscription_details." })),
+		subscription_details: Schema.NullOr(Schema.Struct({ subscription: Schema.String.pipe(Schema.annotateKey({ description: "Subscription that created the invoice." })) })).pipe(Schema.annotateKey({ description: "Set when a subscription created the invoice." }))
+	})).pipe(Schema.annotateKey({ description: "Object that created the invoice." })),
+	status: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Status: draft, open, paid, uncollectible, or void." })),
+	number: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Invoice number shown to the customer." })),
+	currency: Schema.String.pipe(Schema.annotateKey({ description: "Three-letter currency code, in lowercase." })),
+	subtotal: Long.pipe(Schema.annotateKey({ description: "Total before invoice-level discounts and exclusive tax." })),
+	total: Long.pipe(Schema.annotateKey({ description: "Total after discounts and taxes." })),
+	total_excluding_tax: Schema.NullOr(Long).pipe(Schema.annotateKey({ description: "Total after discounts, without tax." })),
+	amount_due: Long.pipe(Schema.annotateKey({ description: "Amount due now." })),
+	amount_paid: Long.pipe(Schema.annotateKey({ description: "Amount paid." })),
+	amount_remaining: Long.pipe(Schema.annotateKey({ description: "Amount due minus amount paid." })),
+	amount_overpaid: Long.pipe(Schema.annotateKey({ description: "Overpaid amount, credited to the customer balance." })),
+	attempt_count: Long.pipe(Schema.annotateKey({ description: "Payment attempts made by the retry schedule." })),
+	billing_reason: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Why the invoice was created." })),
+	collection_method: Schema.String.pipe(Schema.annotateKey({ description: "How the invoice is paid: charge_automatically or send_invoice." })),
+	due_date: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Due date. Only set for send_invoice." })),
+	period_start: UnixTime.pipe(Schema.annotateKey({ description: "Earliest time items can belong to the invoice." })),
+	period_end: UnixTime.pipe(Schema.annotateKey({ description: "Latest time items can belong to the invoice." })),
+	effective_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Date of issue." })),
 	status_transitions: Schema.Struct({
-		finalized_at: Schema.NullOr(UnixTime).pipe(field(110, "Time when the invoice was finalized.")),
-		paid_at: Schema.NullOr(UnixTime).pipe(field(111, "Time when the invoice was paid.")),
-		voided_at: Schema.NullOr(UnixTime).pipe(field(112, "Time when the invoice was voided.")),
-		marked_uncollectible_at: Schema.NullOr(UnixTime).pipe(field(113, "Time when the invoice was marked uncollectible."))
-	}).pipe(field(25, "Times of status changes.")),
-	metadata: Metadata.pipe(field(26, "Key-value pairs set on the invoice.")),
-	_deleted: deleted(27),
-	test_clock: Schema.NullOr(Schema.String).pipe(field(28, "Test clock the invoice belongs to. Sandbox only.")),
-	customer_email: Schema.NullOr(Schema.String).pipe(field(29, "Customer email. Fixed when the invoice is finalized.")),
-	customer_name: Schema.NullOr(Schema.String).pipe(field(30, "Customer name. Fixed when the invoice is finalized.")),
-	customer_phone: Schema.NullOr(Schema.String).pipe(field(31, "Customer phone number. Fixed when the invoice is finalized.")),
-	customer_address: Schema.NullOr(address(120)).pipe(field(32, "Customer address. Fixed when the invoice is finalized.")),
-	customer_shipping: Schema.NullOr(shipping(130)).pipe(field(33, "Customer shipping details. Fixed when the invoice is finalized."))
+		finalized_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when the invoice was finalized." })),
+		paid_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when the invoice was paid." })),
+		voided_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when the invoice was voided." })),
+		marked_uncollectible_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when the invoice was marked uncollectible." }))
+	}).pipe(Schema.annotateKey({ description: "Times of status changes." })),
+	metadata: Metadata.pipe(Schema.annotateKey({ description: "Key-value pairs set on the invoice." })),
+	_deleted: deleted,
+	test_clock: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Test clock the invoice belongs to. Sandbox only." })),
+	customer_email: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer email. Fixed when the invoice is finalized." })),
+	customer_name: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer name. Fixed when the invoice is finalized." })),
+	customer_phone: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer phone number. Fixed when the invoice is finalized." })),
+	customer_address: Schema.NullOr(address).pipe(Schema.annotateKey({ description: "Customer address. Fixed when the invoice is finalized." })),
+	customer_shipping: Schema.NullOr(shipping).pipe(Schema.annotateKey({ description: "Customer shipping details. Fixed when the invoice is finalized." }))
 }).annotate({ description: "Invoices in a Stripe account. Deleted drafts are marked deleted." }).pipe(Iceberg.identifier("id"));
 const InvoiceObjectSchema = InvoiceSchema.mapFields(Struct.omit(["version", "_deleted"]));
 //#endregion
@@ -488,30 +481,30 @@ const makeInvoices = (client) => Resource.entity({
 //#endregion
 //#region src/schemas/prices.ts
 const PriceSchema = Schema.Struct({
-	id: Schema.String.pipe(field(1, "Unique price identifier.")),
-	version: version(2),
-	created: UnixTime.pipe(field(3, "Time when the price was created.")),
-	livemode: Schema.Boolean.pipe(field(4, "Whether the price exists in live mode.")),
-	active: Schema.Boolean.pipe(field(5, "Whether the price can be used for new purchases.")),
-	product: Schema.String.pipe(field(6, "Product the price belongs to.")),
-	currency: Schema.String.pipe(field(7, "Three-letter currency code, in lowercase.")),
-	type: Schema.String.pipe(field(8, "Price type: one_time or recurring.")),
-	billing_scheme: Schema.String.pipe(field(9, "How the amount is computed: per_unit or tiered.")),
-	unit_amount: Schema.NullOr(Long).pipe(field(10, "Unit amount in the smallest currency unit. Null for tiered prices.")),
-	unit_amount_decimal: Schema.NullOr(Schema.String).pipe(field(11, "Unit amount as a decimal string, for sub-cent amounts.")),
-	tiers_mode: Schema.NullOr(Schema.String).pipe(field(12, "Tier mode: graduated or volume.")),
-	lookup_key: Schema.NullOr(Schema.String).pipe(field(13, "Key used to look up the price.")),
-	nickname: Schema.NullOr(Schema.String).pipe(field(14, "Internal name of the price.")),
-	tax_behavior: Schema.NullOr(Schema.String).pipe(field(15, "Whether tax is inclusive, exclusive, or unspecified.")),
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique price identifier." })),
+	version,
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the price was created." })),
+	livemode: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the price exists in live mode." })),
+	active: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the price can be used for new purchases." })),
+	product: Schema.String.pipe(Schema.annotateKey({ description: "Product the price belongs to." })),
+	currency: Schema.String.pipe(Schema.annotateKey({ description: "Three-letter currency code, in lowercase." })),
+	type: Schema.String.pipe(Schema.annotateKey({ description: "Price type: one_time or recurring." })),
+	billing_scheme: Schema.String.pipe(Schema.annotateKey({ description: "How the amount is computed: per_unit or tiered." })),
+	unit_amount: Schema.NullOr(Long).pipe(Schema.annotateKey({ description: "Unit amount in the smallest currency unit. Null for tiered prices." })),
+	unit_amount_decimal: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Unit amount as a decimal string, for sub-cent amounts." })),
+	tiers_mode: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Tier mode: graduated or volume." })),
+	lookup_key: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Key used to look up the price." })),
+	nickname: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Internal name of the price." })),
+	tax_behavior: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Whether tax is inclusive, exclusive, or unspecified." })),
 	recurring: Schema.NullOr(Schema.Struct({
-		interval: Schema.String.pipe(field(100, "Billing interval: day, week, month, or year.")),
-		interval_count: Long.pipe(field(101, "Number of intervals between bills.")),
-		usage_type: Schema.String.pipe(field(102, "Usage type: licensed or metered.")),
-		meter: Schema.optional(Schema.NullOr(Schema.String)).pipe(field(103, "Meter that tracks usage for metered prices.")),
-		trial_period_days: Schema.optional(Schema.NullOr(Long)).pipe(field(104, "Default trial length in days."))
-	})).pipe(field(16, "Billing period of recurring prices.")),
-	metadata: Metadata.pipe(field(17, "Key-value pairs set on the price.")),
-	_deleted: deleted(18)
+		interval: Schema.String.pipe(Schema.annotateKey({ description: "Billing interval: day, week, month, or year." })),
+		interval_count: Long.pipe(Schema.annotateKey({ description: "Number of intervals between bills." })),
+		usage_type: Schema.String.pipe(Schema.annotateKey({ description: "Usage type: licensed or metered." })),
+		meter: Schema.optional(Schema.NullOr(Schema.String)).pipe(Schema.annotateKey({ description: "Meter that tracks usage for metered prices." })),
+		trial_period_days: Schema.optional(Schema.NullOr(Long)).pipe(Schema.annotateKey({ description: "Default trial length in days." }))
+	})).pipe(Schema.annotateKey({ description: "Billing period of recurring prices." })),
+	metadata: Metadata.pipe(Schema.annotateKey({ description: "Key-value pairs set on the price." })),
+	_deleted: deleted
 }).annotate({ description: "Prices in a Stripe account, including inactive ones." }).pipe(Iceberg.identifier("id"));
 const PriceObjectSchema = PriceSchema.mapFields(Struct.omit(["version", "_deleted"]));
 //#endregion
@@ -538,22 +531,22 @@ const makePrices = (client) => Resource.entity({
 //#endregion
 //#region src/schemas/products.ts
 const ProductSchema = Schema.Struct({
-	id: Schema.String.pipe(field(1, "Unique product identifier.")),
-	version: version(2),
-	created: UnixTime.pipe(field(3, "Time when the product was created.")),
-	updated: UnixTime.pipe(field(4, "Time when the product was last changed, in whole seconds.")),
-	livemode: Schema.Boolean.pipe(field(5, "Whether the product exists in live mode.")),
-	active: Schema.Boolean.pipe(field(6, "Whether the product can be bought. False when archived.")),
-	name: Schema.String.pipe(field(7, "Product name.")),
-	description: Schema.NullOr(Schema.String).pipe(field(8, "Product description.")),
-	default_price: Schema.NullOr(Schema.String).pipe(field(9, "Default price of the product.")),
-	tax_code: Schema.NullOr(Schema.String).pipe(field(10, "Tax code of the product.")),
-	unit_label: Schema.NullOr(Schema.String).pipe(field(11, "Label for units on receipts.")),
-	url: Schema.NullOr(Schema.String).pipe(field(12, "Public web page of the product.")),
-	shippable: Schema.NullOr(Schema.Boolean).pipe(field(13, "Whether the product is shipped as physical goods.")),
-	statement_descriptor: Schema.NullOr(Schema.String).pipe(field(14, "Text shown on card statements for subscription payments.")),
-	metadata: Metadata.pipe(field(15, "Key-value pairs set on the product.")),
-	_deleted: deleted(16)
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique product identifier." })),
+	version,
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the product was created." })),
+	updated: UnixTime.pipe(Schema.annotateKey({ description: "Time when the product was last changed, in whole seconds." })),
+	livemode: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the product exists in live mode." })),
+	active: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the product can be bought. False when archived." })),
+	name: Schema.String.pipe(Schema.annotateKey({ description: "Product name." })),
+	description: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Product description." })),
+	default_price: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Default price of the product." })),
+	tax_code: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Tax code of the product." })),
+	unit_label: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Label for units on receipts." })),
+	url: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Public web page of the product." })),
+	shippable: Schema.NullOr(Schema.Boolean).pipe(Schema.annotateKey({ description: "Whether the product is shipped as physical goods." })),
+	statement_descriptor: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Text shown on card statements for subscription payments." })),
+	metadata: Metadata.pipe(Schema.annotateKey({ description: "Key-value pairs set on the product." })),
+	_deleted: deleted
 }).annotate({ description: "Products in a Stripe account, including archived ones." }).pipe(Iceberg.identifier("id"));
 const ProductObjectSchema = ProductSchema.mapFields(Struct.omit(["version", "_deleted"]));
 //#endregion
@@ -580,21 +573,21 @@ const makeProducts = (client) => Resource.entity({
 //#endregion
 //#region src/schemas/refunds.ts
 const RefundSchema = Schema.Struct({
-	id: Schema.String.pipe(field(1, "Unique refund identifier.")),
-	version: version(2),
-	created: UnixTime.pipe(field(3, "Time when the refund was created.")),
-	amount: Long.pipe(field(4, "Refunded amount, in the smallest currency unit.")),
-	currency: Schema.String.pipe(field(5, "Three-letter currency code, in lowercase.")),
-	status: Schema.NullOr(Schema.String).pipe(field(6, "Status: pending, requires_action, succeeded, failed, or canceled.")),
-	pending_reason: Schema.optional(Schema.NullOr(Schema.String)).pipe(field(7, "Why the refund is pending.")),
-	reason: Schema.NullOr(Schema.String).pipe(field(8, "Why the refund was made.")),
-	failure_reason: Schema.optional(Schema.NullOr(Schema.String)).pipe(field(9, "Why the refund failed.")),
-	charge: Schema.NullOr(Schema.String).pipe(field(10, "Charge that was refunded.")),
-	payment_intent: Schema.NullOr(Schema.String).pipe(field(11, "Payment intent that was refunded.")),
-	customer: Schema.optional(Schema.NullOr(Schema.String)).pipe(field(12, "Customer of the refund.")),
-	customer_account: Schema.optional(Schema.NullOr(Schema.String)).pipe(field(13, "Account that represents the customer, for Accounts v2.")),
-	balance_transaction: Schema.NullOr(Schema.String).pipe(field(14, "Balance transaction for the refund.")),
-	metadata: Metadata.pipe(field(15, "Key-value pairs set on the refund."))
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique refund identifier." })),
+	version,
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the refund was created." })),
+	amount: Long.pipe(Schema.annotateKey({ description: "Refunded amount, in the smallest currency unit." })),
+	currency: Schema.String.pipe(Schema.annotateKey({ description: "Three-letter currency code, in lowercase." })),
+	status: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Status: pending, requires_action, succeeded, failed, or canceled." })),
+	pending_reason: Schema.optional(Schema.NullOr(Schema.String)).pipe(Schema.annotateKey({ description: "Why the refund is pending." })),
+	reason: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Why the refund was made." })),
+	failure_reason: Schema.optional(Schema.NullOr(Schema.String)).pipe(Schema.annotateKey({ description: "Why the refund failed." })),
+	charge: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Charge that was refunded." })),
+	payment_intent: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Payment intent that was refunded." })),
+	customer: Schema.optional(Schema.NullOr(Schema.String)).pipe(Schema.annotateKey({ description: "Customer of the refund." })),
+	customer_account: Schema.optional(Schema.NullOr(Schema.String)).pipe(Schema.annotateKey({ description: "Account that represents the customer, for Accounts v2." })),
+	balance_transaction: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Balance transaction for the refund." })),
+	metadata: Metadata.pipe(Schema.annotateKey({ description: "Key-value pairs set on the refund." }))
 }).annotate({ description: "Refunds in a Stripe account." }).pipe(Iceberg.identifier("id"));
 const RefundObjectSchema = RefundSchema.mapFields(Struct.omit(["version"]));
 //#endregion
@@ -622,51 +615,51 @@ const makeRefunds = (client) => Resource.entity({
 //#endregion
 //#region src/schemas/subscriptions.ts
 const SubscriptionItemSchema = Schema.Struct({
-	id: Schema.String.pipe(field(301, "Unique subscription item identifier.")),
-	created: UnixTime.pipe(field(302, "Time when the item was created.")),
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique subscription item identifier." })),
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the item was created." })),
 	price: Schema.Struct({
-		id: Schema.String.pipe(field(304, "Price identifier.")),
-		product: Schema.String.pipe(field(305, "Product the price belongs to."))
-	}).pipe(field(303, "Price of the item.")),
-	quantity: Schema.optional(Long).pipe(field(306, "Quantity billed for the item.")),
-	current_period_start: UnixTime.pipe(field(307, "Start of the item's current billing period.")),
-	current_period_end: UnixTime.pipe(field(308, "End of the item's current billing period."))
+		id: Schema.String.pipe(Schema.annotateKey({ description: "Price identifier." })),
+		product: Schema.String.pipe(Schema.annotateKey({ description: "Product the price belongs to." }))
+	}).pipe(Schema.annotateKey({ description: "Price of the item." })),
+	quantity: Schema.optional(Long).pipe(Schema.annotateKey({ description: "Quantity billed for the item." })),
+	current_period_start: UnixTime.pipe(Schema.annotateKey({ description: "Start of the item's current billing period." })),
+	current_period_end: UnixTime.pipe(Schema.annotateKey({ description: "End of the item's current billing period." }))
 });
 const SubscriptionSchema = Schema.Struct({
-	id: Schema.String.pipe(field(1, "Unique subscription identifier.")),
-	version: version(2),
-	created: UnixTime.pipe(field(3, "Time when the subscription was created.")),
-	livemode: Schema.Boolean.pipe(field(4, "Whether the subscription exists in live mode.")),
-	customer: Schema.NullOr(Schema.String).pipe(field(5, "Customer who owns the subscription.")),
-	customer_account: Schema.NullOr(Schema.String).pipe(field(6, "Account that represents the customer, for Accounts v2.")),
-	status: Schema.String.pipe(field(7, "Status, such as trialing, active, past_due, canceled, unpaid, or paused.")),
-	currency: Schema.String.pipe(field(8, "Three-letter currency code, in lowercase.")),
-	collection_method: Schema.String.pipe(field(9, "How invoices are paid: charge_automatically or send_invoice.")),
-	start_date: UnixTime.pipe(field(10, "Time when the subscription started. Can be backdated.")),
-	billing_cycle_anchor: UnixTime.pipe(field(11, "Reference point for billing dates.")),
-	cancel_at: Schema.NullOr(UnixTime).pipe(field(12, "Time when the subscription will cancel.")),
-	cancel_at_period_end: Schema.Boolean.pipe(field(13, "Whether the subscription cancels at the end of the period.")),
-	canceled_at: Schema.NullOr(UnixTime).pipe(field(14, "Time when cancellation was requested.")),
-	ended_at: Schema.NullOr(UnixTime).pipe(field(15, "Time when the subscription ended.")),
-	trial_start: Schema.NullOr(UnixTime).pipe(field(16, "Start of the trial.")),
-	trial_end: Schema.NullOr(UnixTime).pipe(field(17, "End of the trial.")),
-	days_until_due: Schema.NullOr(Long).pipe(field(18, "Days to pay invoices. Only set for send_invoice.")),
-	default_payment_method: Schema.NullOr(Schema.String).pipe(field(19, "Default payment method of the subscription.")),
-	latest_invoice: Schema.NullOr(Schema.String).pipe(field(20, "Most recent invoice.")),
-	schedule: Schema.NullOr(Schema.String).pipe(field(21, "Subscription schedule, if any.")),
-	description: Schema.NullOr(Schema.String).pipe(field(22, "Description shown to the customer.")),
+	id: Schema.String.pipe(Schema.annotateKey({ description: "Unique subscription identifier." })),
+	version,
+	created: UnixTime.pipe(Schema.annotateKey({ description: "Time when the subscription was created." })),
+	livemode: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the subscription exists in live mode." })),
+	customer: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Customer who owns the subscription." })),
+	customer_account: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Account that represents the customer, for Accounts v2." })),
+	status: Schema.String.pipe(Schema.annotateKey({ description: "Status, such as trialing, active, past_due, canceled, unpaid, or paused." })),
+	currency: Schema.String.pipe(Schema.annotateKey({ description: "Three-letter currency code, in lowercase." })),
+	collection_method: Schema.String.pipe(Schema.annotateKey({ description: "How invoices are paid: charge_automatically or send_invoice." })),
+	start_date: UnixTime.pipe(Schema.annotateKey({ description: "Time when the subscription started. Can be backdated." })),
+	billing_cycle_anchor: UnixTime.pipe(Schema.annotateKey({ description: "Reference point for billing dates." })),
+	cancel_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when the subscription will cancel." })),
+	cancel_at_period_end: Schema.Boolean.pipe(Schema.annotateKey({ description: "Whether the subscription cancels at the end of the period." })),
+	canceled_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when cancellation was requested." })),
+	ended_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when the subscription ended." })),
+	trial_start: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Start of the trial." })),
+	trial_end: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "End of the trial." })),
+	days_until_due: Schema.NullOr(Long).pipe(Schema.annotateKey({ description: "Days to pay invoices. Only set for send_invoice." })),
+	default_payment_method: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Default payment method of the subscription." })),
+	latest_invoice: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Most recent invoice." })),
+	schedule: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Subscription schedule, if any." })),
+	description: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Description shown to the customer." })),
 	cancellation_details: Schema.NullOr(Schema.Struct({
-		reason: Schema.NullOr(Schema.String).pipe(field(100, "Why the subscription was canceled.")),
-		feedback: Schema.NullOr(Schema.String).pipe(field(101, "Reason the customer picked when canceling.")),
-		comment: Schema.NullOr(Schema.String).pipe(field(102, "Free-text comment from the customer."))
-	})).pipe(field(23, "Why the subscription was canceled.")),
+		reason: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Why the subscription was canceled." })),
+		feedback: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Reason the customer picked when canceling." })),
+		comment: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Free-text comment from the customer." }))
+	})).pipe(Schema.annotateKey({ description: "Why the subscription was canceled." })),
 	pause_collection: Schema.NullOr(Schema.Struct({
-		behavior: Schema.String.pipe(field(110, "What happens to invoices while paused.")),
-		resumes_at: Schema.NullOr(UnixTime).pipe(field(111, "Time when collection resumes."))
-	})).pipe(field(24, "Paused payment collection. Not the same as status paused.")),
-	items: Schema.Array(SubscriptionItemSchema.annotate({ fieldId: 300 })).pipe(field(25, "All items of the subscription.")),
-	metadata: Metadata.pipe(field(26, "Key-value pairs set on the subscription.")),
-	test_clock: Schema.NullOr(Schema.String).pipe(field(27, "Test clock the subscription belongs to. Sandbox only."))
+		behavior: Schema.String.pipe(Schema.annotateKey({ description: "What happens to invoices while paused." })),
+		resumes_at: Schema.NullOr(UnixTime).pipe(Schema.annotateKey({ description: "Time when collection resumes." }))
+	})).pipe(Schema.annotateKey({ description: "Paused payment collection. Not the same as status paused." })),
+	items: Schema.Array(SubscriptionItemSchema).pipe(Schema.annotateKey({ description: "All items of the subscription." })),
+	metadata: Metadata.pipe(Schema.annotateKey({ description: "Key-value pairs set on the subscription." })),
+	test_clock: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Test clock the subscription belongs to. Sandbox only." }))
 }).annotate({ description: "Subscriptions in a Stripe account, including canceled ones." }).pipe(Iceberg.identifier("id"));
 const SubscriptionObjectSchema = SubscriptionSchema.mapFields((fields) => ({
 	...Struct.omit(fields, ["version"]),
@@ -846,4 +839,4 @@ const layerConfig = (config) => Layer.unwrap(Config.unwrap(config).pipe(Effect.m
 //#endregion
 export { CustomerSchema as _, SubscriptionItemSchema as a, ChargeSchema as b, RefundObjectSchema as c, ProductSchema as d, PriceObjectSchema as f, CustomerObjectSchema as g, InvoiceSchema as h, webhookPath as i, RefundSchema as l, InvoiceObjectSchema as m, connector_exports as n, SubscriptionObjectSchema as o, PriceSchema as p, layerConfig as r, SubscriptionSchema as s, StripeConnector as t, ProductObjectSchema as u, StripeEventSchema as v, client_exports as x, ChargeObjectSchema as y };
 
-//# sourceMappingURL=src-DXjXItdQ.mjs.map
+//# sourceMappingURL=src-DXKdOBgM.mjs.map