chargebee 3.16.0 → 3.17.0-beta.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+### v3.17.0-beta.1 (2025-12-10)
+
+### Enhancements
+* add webhook event handler to process chargebee-events.
+* deprecated `WebhookContentType` class, added `WebhookEventType` class.
+
 ### v3.16.0 (2025-12-01)
 * * * 
 

package/README.md

@@ -148,6 +148,174 @@ const chargebeeSiteEU = new Chargebee({
 });
 ```
 
+### Handle webhooks
+
+Use the webhook handlers to parse and route webhook payloads from Chargebee with full TypeScript support.
+
+#### Quick Start: Using the default `webhook` instance
+
+The simplest way to handle webhooks is using the pre-configured `webhook` instance:
+
+```typescript
+import express from 'express';
+import { webhook, type WebhookEvent } from 'chargebee';
+
+const app = express();
+app.use(express.json());
+
+webhook.on('subscription_created', async (event: WebhookEvent) => {
+  console.log(`Subscription created: ${event.id}`);
+  const subscription = event.content.subscription;
+  console.log(`Customer: ${subscription.customer_id}`);
+});
+
+webhook.on('error', (err: Error) => {
+  console.error('Webhook error:', err.message);
+});
+
+app.post('/chargebee/webhooks', (req, res) => {
+  webhook.handle(req.body, req.headers);
+  res.status(200).send('OK');
+});
+
+app.listen(8080);
+```
+
+**Auto-configured Basic Auth:** The default `webhook` instance automatically configures Basic Auth validation if the following environment variables are set:
+
+- `CHARGEBEE_WEBHOOK_USERNAME` - The expected username
+- `CHARGEBEE_WEBHOOK_PASSWORD` - The expected password
+
+When both are present, incoming webhook requests will be validated against these credentials. If not set, no authentication is applied.
+
+#### Creating custom `WebhookHandler` instances
+
+For more control or multiple webhook endpoints, create your own instances:
+
+```typescript
+import express from 'express';
+import { WebhookHandler, basicAuthValidator } from 'chargebee';
+
+const app = express();
+app.use(express.json());
+
+const handler = new WebhookHandler();
+
+// Register event listeners using .on() - events are fully typed
+handler.on('subscription_created', async (event) => {
+  console.log(`Subscription created: ${event.id}`);
+  const subscription = event.content.subscription;
+  console.log(`Customer: ${subscription.customer_id}`);
+  console.log(`Plan: ${subscription.plan_id}`);
+});
+
+handler.on('payment_succeeded', async (event) => {
+  console.log(`Payment succeeded: ${event.id}`);
+  const transaction = event.content.transaction;
+  const customer = event.content.customer;
+  console.log(`Amount: ${transaction.amount}, Customer: ${customer.email}`);
+});
+
+// Optional: Add request validator (e.g., Basic Auth)
+handler.requestValidator = basicAuthValidator((username, password) => {
+  return username === 'admin' && password === 'secret';
+});
+
+app.post('/chargebee/webhooks', (req, res) => {
+  handler.handle(req.body, req.headers);
+  res.status(200).send('OK');
+});
+
+app.listen(8080);
+```
+
+#### Low-level: Parse and handle events manually
+
+For more control, you can parse webhook events manually:
+
+```typescript
+import express from 'express';
+import Chargebee, { type WebhookEvent } from 'chargebee';
+
+const app = express();
+app.use(express.json());
+
+app.post('/chargebee/webhooks', async (req, res) => {
+  try {
+    const event = req.body as WebhookEvent;
+    
+    switch (event.event_type) {
+      case 'subscription_created':
+        // Access event content with proper typing
+        const subscription = event.content.subscription;
+        console.log('Subscription created:', subscription.id);
+        break;
+        
+      case 'payment_succeeded':
+        const transaction = event.content.transaction;
+        console.log('Payment succeeded:', transaction.amount);
+        break;
+        
+      default:
+        console.log('Unhandled event type:', event.event_type);
+    }
+    
+    res.status(200).send('OK');
+  } catch (err) {
+    console.error('Error processing webhook:', err);
+    res.status(500).send('Error processing webhook');
+  }
+});
+
+app.listen(8080);
+```
+
+#### Handling Unhandled Events
+
+By default, if an incoming webhook event type is not recognized or you haven't registered a corresponding callback handler, the SDK provides flexible options to handle these scenarios:
+
+**Using the `unhandled_event` listener:**
+
+```typescript
+import { WebhookHandler } from 'chargebee';
+
+const handler = new WebhookHandler();
+
+handler.on('subscription_created', async (event) => {
+  // Handle subscription created
+});
+
+// Gracefully handle events without registered listeners
+handler.on('unhandled_event', async (event) => {
+  console.log(`Received unhandled event: ${event.event_type}`);
+  // Log for monitoring or store for later processing
+});
+```
+
+**Using the `error` listener for error handling:**
+
+If an error occurs during webhook processing (e.g., invalid JSON, validator failure), the SDK will emit an `error` event:
+
+```typescript
+const handler = new WebhookHandler();
+
+handler.on('subscription_created', async (event) => {
+  // Handle subscription created
+});
+
+// Catch any errors during webhook processing
+handler.on('error', (err) => {
+  console.error('Webhook processing error:', err);
+  // Log to monitoring service, alert team, etc.
+});
+```
+
+**Best Practices:**
+
+- Use `unhandled_event` listener to acknowledge unknown events (return 200 OK) and log them
+- Use `error` listener to catch and handle exceptions thrown during event processing
+- Both listeners help ensure your webhook endpoint remains stable even when new event types are introduced by Chargebee
+
 ### Processing Webhooks - API Version Check
 
 An attribute `api_version` is added to the [Event](https://apidocs.chargebee.com/docs/api/events) resource, which indicates the API version based on which the event content is structured. In your webhook servers, ensure this `api_version` is the same as the [API version](https://apidocs.chargebee.com/docs/api#versions) used by your webhook server's client library.

package/cjs/chargebee.cjs.js

@@ -2,8 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const createChargebee_js_1 = require("./createChargebee.js");
 const FetchClient_js_1 = require("./net/FetchClient.js");
+const handler_js_1 = require("./resources/webhook/handler.js");
+const handler_js_2 = require("./resources/webhook/handler.js");
+const auth_js_1 = require("./resources/webhook/auth.js");
 const httpClient = new FetchClient_js_1.FetchHttpClient();
 const Chargebee = (0, createChargebee_js_1.CreateChargebee)(httpClient);
 module.exports = Chargebee;
 module.exports.Chargebee = Chargebee;
 module.exports.default = Chargebee;
+// Export webhook modules
+module.exports.WebhookHandler = handler_js_1.WebhookHandler;
+module.exports.webhook = handler_js_2.default;
+module.exports.basicAuthValidator = auth_js_1.basicAuthValidator;

package/cjs/resources/webhook/auth.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicAuthValidator = void 0;
+const basicAuthValidator = (validateCredentials) => {
+    return (headers) => {
+        const authHeader = headers['authorization'] || headers['Authorization'];
+        if (!authHeader) {
+            throw new Error('Invalid authorization header');
+        }
+        const authStr = Array.isArray(authHeader) ? authHeader[0] : authHeader;
+        if (!authStr) {
+            throw new Error('Invalid authorization header');
+        }
+        const parts = authStr.split(' ');
+        if (parts.length !== 2 || parts[0] !== 'Basic') {
+            throw new Error('Invalid authorization header');
+        }
+        const credentials = Buffer.from(parts[1], 'base64').toString().split(':');
+        if (credentials.length !== 2) {
+            throw new Error('Invalid credentials');
+        }
+        if (!validateCredentials(credentials[0], credentials[1])) {
+            throw new Error('Invalid credentials');
+        }
+    };
+};
+exports.basicAuthValidator = basicAuthValidator;

package/cjs/resources/webhook/content.js

@@ -0,0 +1,3 @@
+"use strict";
+///<reference path='../../../types/index.d.ts'/>
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/resources/webhook/handler.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookHandler = void 0;
+const node_events_1 = require("node:events");
+const auth_js_1 = require("./auth.js");
+class WebhookHandler extends node_events_1.EventEmitter {
+    constructor() {
+        super({ captureRejections: true });
+    }
+    handle(body, headers) {
+        try {
+            if (this.requestValidator && headers) {
+                this.requestValidator(headers);
+            }
+            const event = typeof body === 'string' ? JSON.parse(body) : body;
+            const eventType = event.event_type;
+            if (this.listenerCount(eventType) > 0) {
+                this.emit(eventType, event);
+            }
+            else {
+                this.emit('unhandled_event', event);
+            }
+        }
+        catch (err) {
+            this.emit('error', err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+}
+exports.WebhookHandler = WebhookHandler;
+const webhook = new WebhookHandler();
+// Auto-configure basic auth if env vars are present
+const username = process.env.CHARGEBEE_WEBHOOK_USERNAME;
+const password = process.env.CHARGEBEE_WEBHOOK_PASSWORD;
+if (username && password) {
+    webhook.requestValidator = (0, auth_js_1.basicAuthValidator)((u, p) => u === username && p === password);
+}
+exports.default = webhook;

package/esm/chargebee.esm.js

@@ -3,3 +3,7 @@ import { FetchHttpClient } from './net/FetchClient.js';
 const httpClient = new FetchHttpClient();
 const Chargebee = CreateChargebee(httpClient);
 export default Chargebee;
+// Export webhook modules
+export { WebhookHandler } from './resources/webhook/handler.js';
+export { default as webhook } from './resources/webhook/handler.js';
+export { basicAuthValidator } from './resources/webhook/auth.js';

package/esm/resources/webhook/auth.js

@@ -0,0 +1,23 @@
+export const basicAuthValidator = (validateCredentials) => {
+    return (headers) => {
+        const authHeader = headers['authorization'] || headers['Authorization'];
+        if (!authHeader) {
+            throw new Error('Invalid authorization header');
+        }
+        const authStr = Array.isArray(authHeader) ? authHeader[0] : authHeader;
+        if (!authStr) {
+            throw new Error('Invalid authorization header');
+        }
+        const parts = authStr.split(' ');
+        if (parts.length !== 2 || parts[0] !== 'Basic') {
+            throw new Error('Invalid authorization header');
+        }
+        const credentials = Buffer.from(parts[1], 'base64').toString().split(':');
+        if (credentials.length !== 2) {
+            throw new Error('Invalid credentials');
+        }
+        if (!validateCredentials(credentials[0], credentials[1])) {
+            throw new Error('Invalid credentials');
+        }
+    };
+};

package/esm/resources/webhook/content.js

@@ -0,0 +1,2 @@
+///<reference path='../../../types/index.d.ts'/>
+export {};

package/esm/resources/webhook/handler.js

@@ -0,0 +1,33 @@
+import { EventEmitter } from 'node:events';
+import { basicAuthValidator } from './auth.js';
+export class WebhookHandler extends EventEmitter {
+    constructor() {
+        super({ captureRejections: true });
+    }
+    handle(body, headers) {
+        try {
+            if (this.requestValidator && headers) {
+                this.requestValidator(headers);
+            }
+            const event = typeof body === 'string' ? JSON.parse(body) : body;
+            const eventType = event.event_type;
+            if (this.listenerCount(eventType) > 0) {
+                this.emit(eventType, event);
+            }
+            else {
+                this.emit('unhandled_event', event);
+            }
+        }
+        catch (err) {
+            this.emit('error', err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+}
+const webhook = new WebhookHandler();
+// Auto-configure basic auth if env vars are present
+const username = process.env.CHARGEBEE_WEBHOOK_USERNAME;
+const password = process.env.CHARGEBEE_WEBHOOK_PASSWORD;
+if (username && password) {
+    webhook.requestValidator = basicAuthValidator((u, p) => u === username && p === password);
+}
+export default webhook;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "chargebee",
-  "version": "3.16.0",
+  "version": "3.17.0-beta.1",
   "description": "A library for integrating with Chargebee.",
   "scripts": {
     "prepack": "npm install && npm run build",
+    "test": "mocha -r ts-node/register 'test/**/*.test.ts'",
     "build": "npm run build-esm && npm run build-cjs",
     "build-esm": "rm -rf esm && mkdir -p esm && tsc -p tsconfig.esm.json && echo '{\"type\":\"module\"}' > esm/package.json",
     "build-cjs": "rm -rf cjs && mkdir -p cjs && tsc -p tsconfig.cjs.json && echo '{\"type\":\"commonjs\"}' > cjs/package.json",
@@ -32,8 +33,6 @@
       "url": "http://github.com/chargebee/chargebee-node/blob/master/LICENSE"
     }
   ],
-  "dependencies": {
-  },
   "exports": {
     "types": "./types/index.d.ts",
     "browser": {
@@ -62,13 +61,19 @@
     }
   },
   "devDependencies": {
-    "@types/node": "20.0.0",
+    "@types/chai": "^4.3.5",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "20.12.0",
+    "chai": "^4.3.7",
+    "mocha": "^10.2.0",
     "prettier": "^3.3.3",
-    "typescript": "^5.5.4"
+    "ts-node": "^10.9.1",
+    "typescript": "^5.5.4",
+    "undici-types": "^7.16.0"
   },
   "prettier": {
     "semi": true,
     "singleQuote": true,
     "parser": "typescript"
   }
-}
+}

package/types/index.d.ts

@@ -250,4 +250,69 @@ declare module 'chargebee' {
     virtualBankAccount: VirtualBankAccount.VirtualBankAccountResource;
     webhookEndpoint: WebhookEndpoint.WebhookEndpointResource;
   }
+
+  // Webhook Handler
+  export type WebhookEventName = EventTypeEnum | 'unhandled_event';
+  export type WebhookEventTypeValue = `${WebhookEventType}`;
+  /** @deprecated Use WebhookEventTypeValue instead */
+  export type WebhookContentTypeValue = WebhookEventTypeValue;
+
+  export type WebhookEventListener<
+    T extends WebhookEventType = WebhookEventType,
+  > = (event: WebhookEvent<T>) => Promise<void> | void;
+  export type WebhookErrorListener = (error: Error) => Promise<void> | void;
+
+  // Helper type to map string literal to enum member
+  type StringToWebhookEventType<S extends WebhookEventTypeValue> = {
+    [K in WebhookEventType]: `${K}` extends S ? K : never;
+  }[WebhookEventType];
+
+  export class WebhookHandler {
+    on<T extends WebhookEventType>(
+      eventName: T,
+      listener: WebhookEventListener<T>,
+    ): this;
+    on<S extends WebhookEventTypeValue>(
+      eventName: S,
+      listener: WebhookEventListener<StringToWebhookEventType<S>>,
+    ): this;
+    on(eventName: 'unhandled_event', listener: WebhookEventListener): this;
+    on(eventName: 'error', listener: WebhookErrorListener): this;
+    once<T extends WebhookEventType>(
+      eventName: T,
+      listener: WebhookEventListener<T>,
+    ): this;
+    once<S extends WebhookEventTypeValue>(
+      eventName: S,
+      listener: WebhookEventListener<StringToWebhookEventType<S>>,
+    ): this;
+    once(eventName: 'unhandled_event', listener: WebhookEventListener): this;
+    once(eventName: 'error', listener: WebhookErrorListener): this;
+    off<T extends WebhookEventType>(
+      eventName: T,
+      listener: WebhookEventListener<T>,
+    ): this;
+    off<S extends WebhookEventTypeValue>(
+      eventName: S,
+      listener: WebhookEventListener<StringToWebhookEventType<S>>,
+    ): this;
+    off(eventName: 'unhandled_event', listener: WebhookEventListener): this;
+    off(eventName: 'error', listener: WebhookErrorListener): this;
+    handle(
+      body: string | object,
+      headers?: Record<string, string | string[] | undefined>,
+    ): void;
+    onError?: (error: any) => void;
+    requestValidator?: (
+      headers: Record<string, string | string[] | undefined>,
+    ) => void;
+  }
+
+  // Webhook Auth
+  export function basicAuthValidator(
+    validateCredentials: (username: string, password: string) => boolean,
+  ): (headers: Record<string, string | string[] | undefined>) => void;
+
+  // Default webhook handler instance
+  export const webhook: WebhookHandler;
 }

package/types/resources/WebhookEvent.d.ts

@@ -3,7 +3,7 @@
 ///<reference path='./filter.d.ts'/>
 
 declare module 'chargebee' {
-  export enum WebhookContentType {
+  export enum WebhookEventType {
     SubscriptionPauseScheduled = 'subscription_pause_scheduled',
     CustomerBusinessEntityChanged = 'customer_business_entity_changed',
     SubscriptionAdvanceInvoiceScheduleAdded = 'subscription_advance_invoice_schedule_added',
@@ -220,230 +220,232 @@ declare module 'chargebee' {
     PlanCreated = 'plan_created',
     PlanUpdated = 'plan_updated',
   }
+  /**
+   * @deprecated Use WebhookEventType instead.
+   */
+  export import WebhookContentType = WebhookEventType;
 
   export type WebhookContentMap = {
-    [WebhookContentType.SubscriptionPauseScheduled]: SubscriptionPauseScheduledContent;
-    [WebhookContentType.CustomerBusinessEntityChanged]: CustomerBusinessEntityChangedContent;
-    [WebhookContentType.SubscriptionAdvanceInvoiceScheduleAdded]: SubscriptionAdvanceInvoiceScheduleAddedContent;
-    [WebhookContentType.GiftExpired]: GiftExpiredContent;
-    [WebhookContentType.TaxWithheldDeleted]: TaxWithheldDeletedContent;
-    [WebhookContentType.UnbilledChargesDeleted]: UnbilledChargesDeletedContent;
-    [WebhookContentType.CouponUpdated]: CouponUpdatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemReactivated]: OmnichannelSubscriptionItemReactivatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemRenewed]: OmnichannelSubscriptionItemRenewedContent;
-    [WebhookContentType.UnbilledChargesCreated]: UnbilledChargesCreatedContent;
-    [WebhookContentType.SubscriptionResumed]: SubscriptionResumedContent;
-    [WebhookContentType.OmnichannelOneTimeOrderItemCancelled]: OmnichannelOneTimeOrderItemCancelledContent;
-    [WebhookContentType.SubscriptionCancelled]: SubscriptionCancelledContent;
-    [WebhookContentType.ItemEntitlementsRemoved]: ItemEntitlementsRemovedContent;
-    [WebhookContentType.BusinessEntityCreated]: BusinessEntityCreatedContent;
-    [WebhookContentType.CouponSetUpdated]: CouponSetUpdatedContent;
-    [WebhookContentType.DifferentialPriceUpdated]: DifferentialPriceUpdatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemPaused]: OmnichannelSubscriptionItemPausedContent;
-    [WebhookContentType.EntitlementOverridesRemoved]: EntitlementOverridesRemovedContent;
-    [WebhookContentType.SubscriptionActivatedWithBackdating]: SubscriptionActivatedWithBackdatingContent;
-    [WebhookContentType.SubscriptionTrialEndReminder]: SubscriptionTrialEndReminderContent;
-    [WebhookContentType.SubscriptionShippingAddressUpdated]: SubscriptionShippingAddressUpdatedContent;
-    [WebhookContentType.VoucherCreateFailed]: VoucherCreateFailedContent;
-    [WebhookContentType.GiftClaimed]: GiftClaimedContent;
-    [WebhookContentType.CustomerDeleted]: CustomerDeletedContent;
-    [WebhookContentType.RefundInitiated]: RefundInitiatedContent;
-    [WebhookContentType.InvoiceGeneratedWithBackdating]: InvoiceGeneratedWithBackdatingContent;
-    [WebhookContentType.OmnichannelTransactionCreated]: OmnichannelTransactionCreatedContent;
-    [WebhookContentType.AddUsagesReminder]: AddUsagesReminderContent;
-    [WebhookContentType.VoucherCreated]: VoucherCreatedContent;
-    [WebhookContentType.RuleUpdated]: RuleUpdatedContent;
-    [WebhookContentType.PaymentSchedulesCreated]: PaymentSchedulesCreatedContent;
-    [WebhookContentType.FeatureActivated]: FeatureActivatedContent;
-    [WebhookContentType.PaymentSourceLocallyDeleted]: PaymentSourceLocallyDeletedContent;
-    [WebhookContentType.InvoiceGenerated]: InvoiceGeneratedContent;
-    [WebhookContentType.VoucherExpired]: VoucherExpiredContent;
-    [WebhookContentType.AuthorizationSucceeded]: AuthorizationSucceededContent;
-    [WebhookContentType.GiftScheduled]: GiftScheduledContent;
-    [WebhookContentType.SubscriptionChangesScheduled]: SubscriptionChangesScheduledContent;
-    [WebhookContentType.SubscriptionChangedWithBackdating]: SubscriptionChangedWithBackdatingContent;
-    [WebhookContentType.OmnichannelSubscriptionItemChanged]: OmnichannelSubscriptionItemChangedContent;
-    [WebhookContentType.GiftUnclaimed]: GiftUnclaimedContent;
-    [WebhookContentType.VirtualBankAccountAdded]: VirtualBankAccountAddedContent;
-    [WebhookContentType.PaymentIntentCreated]: PaymentIntentCreatedContent;
-    [WebhookContentType.CreditNoteCreatedWithBackdating]: CreditNoteCreatedWithBackdatingContent;
-    [WebhookContentType.ContractTermTerminated]: ContractTermTerminatedContent;
-    [WebhookContentType.ItemFamilyUpdated]: ItemFamilyUpdatedContent;
-    [WebhookContentType.OrderCreated]: OrderCreatedContent;
-    [WebhookContentType.PriceVariantDeleted]: PriceVariantDeletedContent;
-    [WebhookContentType.SubscriptionMovementFailed]: SubscriptionMovementFailedContent;
-    [WebhookContentType.CustomerMovedIn]: CustomerMovedInContent;
-    [WebhookContentType.SubscriptionAdvanceInvoiceScheduleUpdated]: SubscriptionAdvanceInvoiceScheduleUpdatedContent;
-    [WebhookContentType.ItemDeleted]: ItemDeletedContent;
-    [WebhookContentType.SubscriptionRampDrafted]: SubscriptionRampDraftedContent;
-    [WebhookContentType.DunningUpdated]: DunningUpdatedContent;
-    [WebhookContentType.ItemEntitlementsUpdated]: ItemEntitlementsUpdatedContent;
-    [WebhookContentType.TokenConsumed]: TokenConsumedContent;
-    [WebhookContentType.HierarchyDeleted]: HierarchyDeletedContent;
-    [WebhookContentType.SubscriptionCancellationScheduled]: SubscriptionCancellationScheduledContent;
-    [WebhookContentType.SubscriptionRenewed]: SubscriptionRenewedContent;
-    [WebhookContentType.FeatureUpdated]: FeatureUpdatedContent;
-    [WebhookContentType.FeatureDeleted]: FeatureDeletedContent;
-    [WebhookContentType.ItemFamilyCreated]: ItemFamilyCreatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemScheduledChangeRemoved]: OmnichannelSubscriptionItemScheduledChangeRemovedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemResumed]: OmnichannelSubscriptionItemResumedContent;
-    [WebhookContentType.PurchaseCreated]: PurchaseCreatedContent;
-    [WebhookContentType.EntitlementOverridesUpdated]: EntitlementOverridesUpdatedContent;
-    [WebhookContentType.ItemFamilyDeleted]: ItemFamilyDeletedContent;
-    [WebhookContentType.SubscriptionResumptionScheduled]: SubscriptionResumptionScheduledContent;
-    [WebhookContentType.FeatureReactivated]: FeatureReactivatedContent;
-    [WebhookContentType.CouponCodesDeleted]: CouponCodesDeletedContent;
-    [WebhookContentType.CardExpired]: CardExpiredContent;
-    [WebhookContentType.CreditNoteUpdated]: CreditNoteUpdatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemDowngraded]: OmnichannelSubscriptionItemDowngradedContent;
-    [WebhookContentType.PriceVariantUpdated]: PriceVariantUpdatedContent;
-    [WebhookContentType.PromotionalCreditsDeducted]: PromotionalCreditsDeductedContent;
-    [WebhookContentType.SubscriptionRampApplied]: SubscriptionRampAppliedContent;
-    [WebhookContentType.SubscriptionPaused]: SubscriptionPausedContent;
-    [WebhookContentType.OrderReadyToProcess]: OrderReadyToProcessContent;
-    [WebhookContentType.FeatureCreated]: FeatureCreatedContent;
-    [WebhookContentType.TransactionDeleted]: TransactionDeletedContent;
-    [WebhookContentType.CreditNoteCreated]: CreditNoteCreatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemResubscribed]: OmnichannelSubscriptionItemResubscribedContent;
-    [WebhookContentType.RecordPurchaseFailed]: RecordPurchaseFailedContent;
-    [WebhookContentType.ItemCreated]: ItemCreatedContent;
-    [WebhookContentType.TransactionUpdated]: TransactionUpdatedContent;
-    [WebhookContentType.MrrUpdated]: MrrUpdatedContent;
-    [WebhookContentType.UnbilledChargesInvoiced]: UnbilledChargesInvoicedContent;
-    [WebhookContentType.ItemPriceUpdated]: ItemPriceUpdatedContent;
-    [WebhookContentType.CouponCodesUpdated]: CouponCodesUpdatedContent;
-    [WebhookContentType.VirtualBankAccountUpdated]: VirtualBankAccountUpdatedContent;
-    [WebhookContentType.ContractTermCreated]: ContractTermCreatedContent;
-    [WebhookContentType.SubscriptionChanged]: SubscriptionChangedContent;
-    [WebhookContentType.PaymentFailed]: PaymentFailedContent;
-    [WebhookContentType.CreditNoteDeleted]: CreditNoteDeletedContent;
-    [WebhookContentType.TaxWithheldRefunded]: TaxWithheldRefundedContent;
-    [WebhookContentType.ContractTermCompleted]: ContractTermCompletedContent;
-    [WebhookContentType.PaymentSchedulesUpdated]: PaymentSchedulesUpdatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemExpired]: OmnichannelSubscriptionItemExpiredContent;
-    [WebhookContentType.CardUpdated]: CardUpdatedContent;
-    [WebhookContentType.CustomerCreated]: CustomerCreatedContent;
-    [WebhookContentType.SubscriptionRenewalReminder]: SubscriptionRenewalReminderContent;
-    [WebhookContentType.OrderDelivered]: OrderDeliveredContent;
-    [WebhookContentType.OmnichannelSubscriptionItemCancellationScheduled]: OmnichannelSubscriptionItemCancellationScheduledContent;
-    [WebhookContentType.OmnichannelSubscriptionItemGracePeriodExpired]: OmnichannelSubscriptionItemGracePeriodExpiredContent;
-    [WebhookContentType.CouponCodesAdded]: CouponCodesAddedContent;
-    [WebhookContentType.GiftCancelled]: GiftCancelledContent;
-    [WebhookContentType.OrderCancelled]: OrderCancelledContent;
-    [WebhookContentType.CouponDeleted]: CouponDeletedContent;
-    [WebhookContentType.SubscriptionScheduledChangesRemoved]: SubscriptionScheduledChangesRemovedContent;
-    [WebhookContentType.PendingInvoiceCreated]: PendingInvoiceCreatedContent;
-    [WebhookContentType.EntitlementOverridesAutoRemoved]: EntitlementOverridesAutoRemovedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemUpgraded]: OmnichannelSubscriptionItemUpgradedContent;
-    [WebhookContentType.SubscriptionBusinessEntityChanged]: SubscriptionBusinessEntityChangedContent;
-    [WebhookContentType.OmnichannelOneTimeOrderCreated]: OmnichannelOneTimeOrderCreatedContent;
-    [WebhookContentType.PaymentSourceDeleted]: PaymentSourceDeletedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemCancelled]: OmnichannelSubscriptionItemCancelledContent;
-    [WebhookContentType.QuoteDeleted]: QuoteDeletedContent;
-    [WebhookContentType.InvoiceUpdated]: InvoiceUpdatedContent;
-    [WebhookContentType.SubscriptionAdvanceInvoiceScheduleRemoved]: SubscriptionAdvanceInvoiceScheduleRemovedContent;
-    [WebhookContentType.CardDeleted]: CardDeletedContent;
-    [WebhookContentType.OrderReadyToShip]: OrderReadyToShipContent;
-    [WebhookContentType.SubscriptionMovedOut]: SubscriptionMovedOutContent;
-    [WebhookContentType.PaymentScheduleSchemeCreated]: PaymentScheduleSchemeCreatedContent;
-    [WebhookContentType.BusinessEntityUpdated]: BusinessEntityUpdatedContent;
-    [WebhookContentType.SubscriptionScheduledResumptionRemoved]: SubscriptionScheduledResumptionRemovedContent;
-    [WebhookContentType.PaymentInitiated]: PaymentInitiatedContent;
-    [WebhookContentType.FeatureArchived]: FeatureArchivedContent;
-    [WebhookContentType.SubscriptionReactivatedWithBackdating]: SubscriptionReactivatedWithBackdatingContent;
-    [WebhookContentType.OmnichannelSubscriptionImported]: OmnichannelSubscriptionImportedContent;
-    [WebhookContentType.TokenExpired]: TokenExpiredContent;
-    [WebhookContentType.CardAdded]: CardAddedContent;
-    [WebhookContentType.CouponCreated]: CouponCreatedContent;
-    [WebhookContentType.RuleDeleted]: RuleDeletedContent;
-    [WebhookContentType.ItemPriceEntitlementsUpdated]: ItemPriceEntitlementsUpdatedContent;
-    [WebhookContentType.ItemPriceDeleted]: ItemPriceDeletedContent;
-    [WebhookContentType.VirtualBankAccountDeleted]: VirtualBankAccountDeletedContent;
-    [WebhookContentType.PaymentScheduleSchemeDeleted]: PaymentScheduleSchemeDeletedContent;
-    [WebhookContentType.SubscriptionCreated]: SubscriptionCreatedContent;
-    [WebhookContentType.SubscriptionEntitlementsCreated]: SubscriptionEntitlementsCreatedContent;
-    [WebhookContentType.OrderReturned]: OrderReturnedContent;
-    [WebhookContentType.SubscriptionDeleted]: SubscriptionDeletedContent;
-    [WebhookContentType.PaymentSourceAdded]: PaymentSourceAddedContent;
-    [WebhookContentType.SubscriptionMovedIn]: SubscriptionMovedInContent;
-    [WebhookContentType.ItemPriceCreated]: ItemPriceCreatedContent;
-    [WebhookContentType.SubscriptionScheduledCancellationRemoved]: SubscriptionScheduledCancellationRemovedContent;
-    [WebhookContentType.PaymentRefunded]: PaymentRefundedContent;
-    [WebhookContentType.UsageFileIngested]: UsageFileIngestedContent;
-    [WebhookContentType.OmnichannelSubscriptionMovedIn]: OmnichannelSubscriptionMovedInContent;
-    [WebhookContentType.DifferentialPriceCreated]: DifferentialPriceCreatedContent;
-    [WebhookContentType.TransactionCreated]: TransactionCreatedContent;
-    [WebhookContentType.PaymentSucceeded]: PaymentSucceededContent;
-    [WebhookContentType.SubscriptionCanceledWithBackdating]: SubscriptionCanceledWithBackdatingContent;
-    [WebhookContentType.UnbilledChargesVoided]: UnbilledChargesVoidedContent;
-    [WebhookContentType.QuoteCreated]: QuoteCreatedContent;
-    [WebhookContentType.CouponSetDeleted]: CouponSetDeletedContent;
-    [WebhookContentType.AttachedItemCreated]: AttachedItemCreatedContent;
-    [WebhookContentType.SalesOrderCreated]: SalesOrderCreatedContent;
-    [WebhookContentType.CustomerChanged]: CustomerChangedContent;
-    [WebhookContentType.SubscriptionStarted]: SubscriptionStartedContent;
-    [WebhookContentType.SubscriptionActivated]: SubscriptionActivatedContent;
-    [WebhookContentType.PaymentSourceExpiring]: PaymentSourceExpiringContent;
-    [WebhookContentType.SubscriptionReactivated]: SubscriptionReactivatedContent;
-    [WebhookContentType.OrderUpdated]: OrderUpdatedContent;
-    [WebhookContentType.SubscriptionScheduledPauseRemoved]: SubscriptionScheduledPauseRemovedContent;
-    [WebhookContentType.SubscriptionCancellationReminder]: SubscriptionCancellationReminderContent;
-    [WebhookContentType.SubscriptionCreatedWithBackdating]: SubscriptionCreatedWithBackdatingContent;
-    [WebhookContentType.SubscriptionRampCreated]: SubscriptionRampCreatedContent;
-    [WebhookContentType.OrderDeleted]: OrderDeletedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemPauseScheduled]: OmnichannelSubscriptionItemPauseScheduledContent;
-    [WebhookContentType.GiftUpdated]: GiftUpdatedContent;
-    [WebhookContentType.SubscriptionTrialExtended]: SubscriptionTrialExtendedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemGracePeriodStarted]: OmnichannelSubscriptionItemGracePeriodStartedContent;
-    [WebhookContentType.CardExpiryReminder]: CardExpiryReminderContent;
-    [WebhookContentType.TokenCreated]: TokenCreatedContent;
-    [WebhookContentType.PromotionalCreditsAdded]: PromotionalCreditsAddedContent;
-    [WebhookContentType.SubscriptionRampUpdated]: SubscriptionRampUpdatedContent;
-    [WebhookContentType.CustomerEntitlementsUpdated]: CustomerEntitlementsUpdatedContent;
-    [WebhookContentType.PaymentSourceExpired]: PaymentSourceExpiredContent;
-    [WebhookContentType.CustomerMovedOut]: CustomerMovedOutContent;
-    [WebhookContentType.SubscriptionEntitlementsUpdated]: SubscriptionEntitlementsUpdatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemDunningExpired]: OmnichannelSubscriptionItemDunningExpiredContent;
-    [WebhookContentType.HierarchyCreated]: HierarchyCreatedContent;
-    [WebhookContentType.AttachedItemDeleted]: AttachedItemDeletedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemScheduledCancellationRemoved]: OmnichannelSubscriptionItemScheduledCancellationRemovedContent;
-    [WebhookContentType.ItemUpdated]: ItemUpdatedContent;
-    [WebhookContentType.CouponSetCreated]: CouponSetCreatedContent;
-    [WebhookContentType.PaymentIntentUpdated]: PaymentIntentUpdatedContent;
-    [WebhookContentType.OrderResent]: OrderResentContent;
-    [WebhookContentType.OmnichannelSubscriptionCreated]: OmnichannelSubscriptionCreatedContent;
-    [WebhookContentType.TaxWithheldRecorded]: TaxWithheldRecordedContent;
-    [WebhookContentType.PriceVariantCreated]: PriceVariantCreatedContent;
-    [WebhookContentType.DifferentialPriceDeleted]: DifferentialPriceDeletedContent;
-    [WebhookContentType.SubscriptionItemsRenewed]: SubscriptionItemsRenewedContent;
-    [WebhookContentType.RuleCreated]: RuleCreatedContent;
-    [WebhookContentType.ContractTermCancelled]: ContractTermCancelledContent;
-    [WebhookContentType.ContractTermRenewed]: ContractTermRenewedContent;
-    [WebhookContentType.InvoiceDeleted]: InvoiceDeletedContent;
-    [WebhookContentType.ItemPriceEntitlementsRemoved]: ItemPriceEntitlementsRemovedContent;
-    [WebhookContentType.SalesOrderUpdated]: SalesOrderUpdatedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemDunningStarted]: OmnichannelSubscriptionItemDunningStartedContent;
-    [WebhookContentType.OmnichannelSubscriptionItemChangeScheduled]: OmnichannelSubscriptionItemChangeScheduledContent;
-    [WebhookContentType.PendingInvoiceUpdated]: PendingInvoiceUpdatedContent;
-    [WebhookContentType.QuoteUpdated]: QuoteUpdatedContent;
-    [WebhookContentType.AttachedItemUpdated]: AttachedItemUpdatedContent;
-    [WebhookContentType.PaymentSourceUpdated]: PaymentSourceUpdatedContent;
-    [WebhookContentType.BusinessEntityDeleted]: BusinessEntityDeletedContent;
-    [WebhookContentType.AuthorizationVoided]: AuthorizationVoidedContent;
-    [WebhookContentType.SubscriptionRampDeleted]: SubscriptionRampDeletedContent;
-    [WebhookContentType.PlanDeleted]: PlanDeletedContent;
-    [WebhookContentType.AddonDeleted]: AddonDeletedContent;
-    [WebhookContentType.AddonUpdated]: AddonUpdatedContent;
-    [WebhookContentType.AddonCreated]: AddonCreatedContent;
-    [WebhookContentType.PlanCreated]: PlanCreatedContent;
-    [WebhookContentType.PlanUpdated]: PlanUpdatedContent;
-  };
-
-  export type ContentFor<T extends WebhookContentType> = WebhookContentMap[T];
-
-  export interface WebhookEvent<
-    T extends WebhookContentType = WebhookContentType,
-  > {
+    [WebhookEventType.SubscriptionPauseScheduled]: SubscriptionPauseScheduledContent;
+    [WebhookEventType.CustomerBusinessEntityChanged]: CustomerBusinessEntityChangedContent;
+    [WebhookEventType.SubscriptionAdvanceInvoiceScheduleAdded]: SubscriptionAdvanceInvoiceScheduleAddedContent;
+    [WebhookEventType.GiftExpired]: GiftExpiredContent;
+    [WebhookEventType.TaxWithheldDeleted]: TaxWithheldDeletedContent;
+    [WebhookEventType.UnbilledChargesDeleted]: UnbilledChargesDeletedContent;
+    [WebhookEventType.CouponUpdated]: CouponUpdatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemReactivated]: OmnichannelSubscriptionItemReactivatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemRenewed]: OmnichannelSubscriptionItemRenewedContent;
+    [WebhookEventType.UnbilledChargesCreated]: UnbilledChargesCreatedContent;
+    [WebhookEventType.SubscriptionResumed]: SubscriptionResumedContent;
+    [WebhookEventType.OmnichannelOneTimeOrderItemCancelled]: OmnichannelOneTimeOrderItemCancelledContent;
+    [WebhookEventType.SubscriptionCancelled]: SubscriptionCancelledContent;
+    [WebhookEventType.ItemEntitlementsRemoved]: ItemEntitlementsRemovedContent;
+    [WebhookEventType.BusinessEntityCreated]: BusinessEntityCreatedContent;
+    [WebhookEventType.CouponSetUpdated]: CouponSetUpdatedContent;
+    [WebhookEventType.DifferentialPriceUpdated]: DifferentialPriceUpdatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemPaused]: OmnichannelSubscriptionItemPausedContent;
+    [WebhookEventType.EntitlementOverridesRemoved]: EntitlementOverridesRemovedContent;
+    [WebhookEventType.SubscriptionActivatedWithBackdating]: SubscriptionActivatedWithBackdatingContent;
+    [WebhookEventType.SubscriptionTrialEndReminder]: SubscriptionTrialEndReminderContent;
+    [WebhookEventType.SubscriptionShippingAddressUpdated]: SubscriptionShippingAddressUpdatedContent;
+    [WebhookEventType.VoucherCreateFailed]: VoucherCreateFailedContent;
+    [WebhookEventType.GiftClaimed]: GiftClaimedContent;
+    [WebhookEventType.CustomerDeleted]: CustomerDeletedContent;
+    [WebhookEventType.RefundInitiated]: RefundInitiatedContent;
+    [WebhookEventType.InvoiceGeneratedWithBackdating]: InvoiceGeneratedWithBackdatingContent;
+    [WebhookEventType.OmnichannelTransactionCreated]: OmnichannelTransactionCreatedContent;
+    [WebhookEventType.AddUsagesReminder]: AddUsagesReminderContent;
+    [WebhookEventType.VoucherCreated]: VoucherCreatedContent;
+    [WebhookEventType.RuleUpdated]: RuleUpdatedContent;
+    [WebhookEventType.PaymentSchedulesCreated]: PaymentSchedulesCreatedContent;
+    [WebhookEventType.FeatureActivated]: FeatureActivatedContent;
+    [WebhookEventType.PaymentSourceLocallyDeleted]: PaymentSourceLocallyDeletedContent;
+    [WebhookEventType.InvoiceGenerated]: InvoiceGeneratedContent;
+    [WebhookEventType.VoucherExpired]: VoucherExpiredContent;
+    [WebhookEventType.AuthorizationSucceeded]: AuthorizationSucceededContent;
+    [WebhookEventType.GiftScheduled]: GiftScheduledContent;
+    [WebhookEventType.SubscriptionChangesScheduled]: SubscriptionChangesScheduledContent;
+    [WebhookEventType.SubscriptionChangedWithBackdating]: SubscriptionChangedWithBackdatingContent;
+    [WebhookEventType.OmnichannelSubscriptionItemChanged]: OmnichannelSubscriptionItemChangedContent;
+    [WebhookEventType.GiftUnclaimed]: GiftUnclaimedContent;
+    [WebhookEventType.VirtualBankAccountAdded]: VirtualBankAccountAddedContent;
+    [WebhookEventType.PaymentIntentCreated]: PaymentIntentCreatedContent;
+    [WebhookEventType.CreditNoteCreatedWithBackdating]: CreditNoteCreatedWithBackdatingContent;
+    [WebhookEventType.ContractTermTerminated]: ContractTermTerminatedContent;
+    [WebhookEventType.ItemFamilyUpdated]: ItemFamilyUpdatedContent;
+    [WebhookEventType.OrderCreated]: OrderCreatedContent;
+    [WebhookEventType.PriceVariantDeleted]: PriceVariantDeletedContent;
+    [WebhookEventType.SubscriptionMovementFailed]: SubscriptionMovementFailedContent;
+    [WebhookEventType.CustomerMovedIn]: CustomerMovedInContent;
+    [WebhookEventType.SubscriptionAdvanceInvoiceScheduleUpdated]: SubscriptionAdvanceInvoiceScheduleUpdatedContent;
+    [WebhookEventType.ItemDeleted]: ItemDeletedContent;
+    [WebhookEventType.SubscriptionRampDrafted]: SubscriptionRampDraftedContent;
+    [WebhookEventType.DunningUpdated]: DunningUpdatedContent;
+    [WebhookEventType.ItemEntitlementsUpdated]: ItemEntitlementsUpdatedContent;
+    [WebhookEventType.TokenConsumed]: TokenConsumedContent;
+    [WebhookEventType.HierarchyDeleted]: HierarchyDeletedContent;
+    [WebhookEventType.SubscriptionCancellationScheduled]: SubscriptionCancellationScheduledContent;
+    [WebhookEventType.SubscriptionRenewed]: SubscriptionRenewedContent;
+    [WebhookEventType.FeatureUpdated]: FeatureUpdatedContent;
+    [WebhookEventType.FeatureDeleted]: FeatureDeletedContent;
+    [WebhookEventType.ItemFamilyCreated]: ItemFamilyCreatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemScheduledChangeRemoved]: OmnichannelSubscriptionItemScheduledChangeRemovedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemResumed]: OmnichannelSubscriptionItemResumedContent;
+    [WebhookEventType.PurchaseCreated]: PurchaseCreatedContent;
+    [WebhookEventType.EntitlementOverridesUpdated]: EntitlementOverridesUpdatedContent;
+    [WebhookEventType.ItemFamilyDeleted]: ItemFamilyDeletedContent;
+    [WebhookEventType.SubscriptionResumptionScheduled]: SubscriptionResumptionScheduledContent;
+    [WebhookEventType.FeatureReactivated]: FeatureReactivatedContent;
+    [WebhookEventType.CouponCodesDeleted]: CouponCodesDeletedContent;
+    [WebhookEventType.CardExpired]: CardExpiredContent;
+    [WebhookEventType.CreditNoteUpdated]: CreditNoteUpdatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemDowngraded]: OmnichannelSubscriptionItemDowngradedContent;
+    [WebhookEventType.PriceVariantUpdated]: PriceVariantUpdatedContent;
+    [WebhookEventType.PromotionalCreditsDeducted]: PromotionalCreditsDeductedContent;
+    [WebhookEventType.SubscriptionRampApplied]: SubscriptionRampAppliedContent;
+    [WebhookEventType.SubscriptionPaused]: SubscriptionPausedContent;
+    [WebhookEventType.OrderReadyToProcess]: OrderReadyToProcessContent;
+    [WebhookEventType.FeatureCreated]: FeatureCreatedContent;
+    [WebhookEventType.TransactionDeleted]: TransactionDeletedContent;
+    [WebhookEventType.CreditNoteCreated]: CreditNoteCreatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemResubscribed]: OmnichannelSubscriptionItemResubscribedContent;
+    [WebhookEventType.RecordPurchaseFailed]: RecordPurchaseFailedContent;
+    [WebhookEventType.ItemCreated]: ItemCreatedContent;
+    [WebhookEventType.TransactionUpdated]: TransactionUpdatedContent;
+    [WebhookEventType.MrrUpdated]: MrrUpdatedContent;
+    [WebhookEventType.UnbilledChargesInvoiced]: UnbilledChargesInvoicedContent;
+    [WebhookEventType.ItemPriceUpdated]: ItemPriceUpdatedContent;
+    [WebhookEventType.CouponCodesUpdated]: CouponCodesUpdatedContent;
+    [WebhookEventType.VirtualBankAccountUpdated]: VirtualBankAccountUpdatedContent;
+    [WebhookEventType.ContractTermCreated]: ContractTermCreatedContent;
+    [WebhookEventType.SubscriptionChanged]: SubscriptionChangedContent;
+    [WebhookEventType.PaymentFailed]: PaymentFailedContent;
+    [WebhookEventType.CreditNoteDeleted]: CreditNoteDeletedContent;
+    [WebhookEventType.TaxWithheldRefunded]: TaxWithheldRefundedContent;
+    [WebhookEventType.ContractTermCompleted]: ContractTermCompletedContent;
+    [WebhookEventType.PaymentSchedulesUpdated]: PaymentSchedulesUpdatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemExpired]: OmnichannelSubscriptionItemExpiredContent;
+    [WebhookEventType.CardUpdated]: CardUpdatedContent;
+    [WebhookEventType.CustomerCreated]: CustomerCreatedContent;
+    [WebhookEventType.SubscriptionRenewalReminder]: SubscriptionRenewalReminderContent;
+    [WebhookEventType.OrderDelivered]: OrderDeliveredContent;
+    [WebhookEventType.OmnichannelSubscriptionItemCancellationScheduled]: OmnichannelSubscriptionItemCancellationScheduledContent;
+    [WebhookEventType.OmnichannelSubscriptionItemGracePeriodExpired]: OmnichannelSubscriptionItemGracePeriodExpiredContent;
+    [WebhookEventType.CouponCodesAdded]: CouponCodesAddedContent;
+    [WebhookEventType.GiftCancelled]: GiftCancelledContent;
+    [WebhookEventType.OrderCancelled]: OrderCancelledContent;
+    [WebhookEventType.CouponDeleted]: CouponDeletedContent;
+    [WebhookEventType.SubscriptionScheduledChangesRemoved]: SubscriptionScheduledChangesRemovedContent;
+    [WebhookEventType.PendingInvoiceCreated]: PendingInvoiceCreatedContent;
+    [WebhookEventType.EntitlementOverridesAutoRemoved]: EntitlementOverridesAutoRemovedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemUpgraded]: OmnichannelSubscriptionItemUpgradedContent;
+    [WebhookEventType.SubscriptionBusinessEntityChanged]: SubscriptionBusinessEntityChangedContent;
+    [WebhookEventType.OmnichannelOneTimeOrderCreated]: OmnichannelOneTimeOrderCreatedContent;
+    [WebhookEventType.PaymentSourceDeleted]: PaymentSourceDeletedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemCancelled]: OmnichannelSubscriptionItemCancelledContent;
+    [WebhookEventType.QuoteDeleted]: QuoteDeletedContent;
+    [WebhookEventType.InvoiceUpdated]: InvoiceUpdatedContent;
+    [WebhookEventType.SubscriptionAdvanceInvoiceScheduleRemoved]: SubscriptionAdvanceInvoiceScheduleRemovedContent;
+    [WebhookEventType.CardDeleted]: CardDeletedContent;
+    [WebhookEventType.OrderReadyToShip]: OrderReadyToShipContent;
+    [WebhookEventType.SubscriptionMovedOut]: SubscriptionMovedOutContent;
+    [WebhookEventType.PaymentScheduleSchemeCreated]: PaymentScheduleSchemeCreatedContent;
+    [WebhookEventType.BusinessEntityUpdated]: BusinessEntityUpdatedContent;
+    [WebhookEventType.SubscriptionScheduledResumptionRemoved]: SubscriptionScheduledResumptionRemovedContent;
+    [WebhookEventType.PaymentInitiated]: PaymentInitiatedContent;
+    [WebhookEventType.FeatureArchived]: FeatureArchivedContent;
+    [WebhookEventType.SubscriptionReactivatedWithBackdating]: SubscriptionReactivatedWithBackdatingContent;
+    [WebhookEventType.OmnichannelSubscriptionImported]: OmnichannelSubscriptionImportedContent;
+    [WebhookEventType.TokenExpired]: TokenExpiredContent;
+    [WebhookEventType.CardAdded]: CardAddedContent;
+    [WebhookEventType.CouponCreated]: CouponCreatedContent;
+    [WebhookEventType.RuleDeleted]: RuleDeletedContent;
+    [WebhookEventType.ItemPriceEntitlementsUpdated]: ItemPriceEntitlementsUpdatedContent;
+    [WebhookEventType.ItemPriceDeleted]: ItemPriceDeletedContent;
+    [WebhookEventType.VirtualBankAccountDeleted]: VirtualBankAccountDeletedContent;
+    [WebhookEventType.PaymentScheduleSchemeDeleted]: PaymentScheduleSchemeDeletedContent;
+    [WebhookEventType.SubscriptionCreated]: SubscriptionCreatedContent;
+    [WebhookEventType.SubscriptionEntitlementsCreated]: SubscriptionEntitlementsCreatedContent;
+    [WebhookEventType.OrderReturned]: OrderReturnedContent;
+    [WebhookEventType.SubscriptionDeleted]: SubscriptionDeletedContent;
+    [WebhookEventType.PaymentSourceAdded]: PaymentSourceAddedContent;
+    [WebhookEventType.SubscriptionMovedIn]: SubscriptionMovedInContent;
+    [WebhookEventType.ItemPriceCreated]: ItemPriceCreatedContent;
+    [WebhookEventType.SubscriptionScheduledCancellationRemoved]: SubscriptionScheduledCancellationRemovedContent;
+    [WebhookEventType.PaymentRefunded]: PaymentRefundedContent;
+    [WebhookEventType.UsageFileIngested]: UsageFileIngestedContent;
+    [WebhookEventType.OmnichannelSubscriptionMovedIn]: OmnichannelSubscriptionMovedInContent;
+    [WebhookEventType.DifferentialPriceCreated]: DifferentialPriceCreatedContent;
+    [WebhookEventType.TransactionCreated]: TransactionCreatedContent;
+    [WebhookEventType.PaymentSucceeded]: PaymentSucceededContent;
+    [WebhookEventType.SubscriptionCanceledWithBackdating]: SubscriptionCanceledWithBackdatingContent;
+    [WebhookEventType.UnbilledChargesVoided]: UnbilledChargesVoidedContent;
+    [WebhookEventType.QuoteCreated]: QuoteCreatedContent;
+    [WebhookEventType.CouponSetDeleted]: CouponSetDeletedContent;
+    [WebhookEventType.AttachedItemCreated]: AttachedItemCreatedContent;
+    [WebhookEventType.SalesOrderCreated]: SalesOrderCreatedContent;
+    [WebhookEventType.CustomerChanged]: CustomerChangedContent;
+    [WebhookEventType.SubscriptionStarted]: SubscriptionStartedContent;
+    [WebhookEventType.SubscriptionActivated]: SubscriptionActivatedContent;
+    [WebhookEventType.PaymentSourceExpiring]: PaymentSourceExpiringContent;
+    [WebhookEventType.SubscriptionReactivated]: SubscriptionReactivatedContent;
+    [WebhookEventType.OrderUpdated]: OrderUpdatedContent;
+    [WebhookEventType.SubscriptionScheduledPauseRemoved]: SubscriptionScheduledPauseRemovedContent;
+    [WebhookEventType.SubscriptionCancellationReminder]: SubscriptionCancellationReminderContent;
+    [WebhookEventType.SubscriptionCreatedWithBackdating]: SubscriptionCreatedWithBackdatingContent;
+    [WebhookEventType.SubscriptionRampCreated]: SubscriptionRampCreatedContent;
+    [WebhookEventType.OrderDeleted]: OrderDeletedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemPauseScheduled]: OmnichannelSubscriptionItemPauseScheduledContent;
+    [WebhookEventType.GiftUpdated]: GiftUpdatedContent;
+    [WebhookEventType.SubscriptionTrialExtended]: SubscriptionTrialExtendedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemGracePeriodStarted]: OmnichannelSubscriptionItemGracePeriodStartedContent;
+    [WebhookEventType.CardExpiryReminder]: CardExpiryReminderContent;
+    [WebhookEventType.TokenCreated]: TokenCreatedContent;
+    [WebhookEventType.PromotionalCreditsAdded]: PromotionalCreditsAddedContent;
+    [WebhookEventType.SubscriptionRampUpdated]: SubscriptionRampUpdatedContent;
+    [WebhookEventType.CustomerEntitlementsUpdated]: CustomerEntitlementsUpdatedContent;
+    [WebhookEventType.PaymentSourceExpired]: PaymentSourceExpiredContent;
+    [WebhookEventType.CustomerMovedOut]: CustomerMovedOutContent;
+    [WebhookEventType.SubscriptionEntitlementsUpdated]: SubscriptionEntitlementsUpdatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemDunningExpired]: OmnichannelSubscriptionItemDunningExpiredContent;
+    [WebhookEventType.HierarchyCreated]: HierarchyCreatedContent;
+    [WebhookEventType.AttachedItemDeleted]: AttachedItemDeletedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemScheduledCancellationRemoved]: OmnichannelSubscriptionItemScheduledCancellationRemovedContent;
+    [WebhookEventType.ItemUpdated]: ItemUpdatedContent;
+    [WebhookEventType.CouponSetCreated]: CouponSetCreatedContent;
+    [WebhookEventType.PaymentIntentUpdated]: PaymentIntentUpdatedContent;
+    [WebhookEventType.OrderResent]: OrderResentContent;
+    [WebhookEventType.OmnichannelSubscriptionCreated]: OmnichannelSubscriptionCreatedContent;
+    [WebhookEventType.TaxWithheldRecorded]: TaxWithheldRecordedContent;
+    [WebhookEventType.PriceVariantCreated]: PriceVariantCreatedContent;
+    [WebhookEventType.DifferentialPriceDeleted]: DifferentialPriceDeletedContent;
+    [WebhookEventType.SubscriptionItemsRenewed]: SubscriptionItemsRenewedContent;
+    [WebhookEventType.RuleCreated]: RuleCreatedContent;
+    [WebhookEventType.ContractTermCancelled]: ContractTermCancelledContent;
+    [WebhookEventType.ContractTermRenewed]: ContractTermRenewedContent;
+    [WebhookEventType.InvoiceDeleted]: InvoiceDeletedContent;
+    [WebhookEventType.ItemPriceEntitlementsRemoved]: ItemPriceEntitlementsRemovedContent;
+    [WebhookEventType.SalesOrderUpdated]: SalesOrderUpdatedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemDunningStarted]: OmnichannelSubscriptionItemDunningStartedContent;
+    [WebhookEventType.OmnichannelSubscriptionItemChangeScheduled]: OmnichannelSubscriptionItemChangeScheduledContent;
+    [WebhookEventType.PendingInvoiceUpdated]: PendingInvoiceUpdatedContent;
+    [WebhookEventType.QuoteUpdated]: QuoteUpdatedContent;
+    [WebhookEventType.AttachedItemUpdated]: AttachedItemUpdatedContent;
+    [WebhookEventType.PaymentSourceUpdated]: PaymentSourceUpdatedContent;
+    [WebhookEventType.BusinessEntityDeleted]: BusinessEntityDeletedContent;
+    [WebhookEventType.AuthorizationVoided]: AuthorizationVoidedContent;
+    [WebhookEventType.SubscriptionRampDeleted]: SubscriptionRampDeletedContent;
+    [WebhookEventType.PlanDeleted]: PlanDeletedContent;
+    [WebhookEventType.AddonDeleted]: AddonDeletedContent;
+    [WebhookEventType.AddonUpdated]: AddonUpdatedContent;
+    [WebhookEventType.AddonCreated]: AddonCreatedContent;
+    [WebhookEventType.PlanCreated]: PlanCreatedContent;
+    [WebhookEventType.PlanUpdated]: PlanUpdatedContent;
+  };
+
+  export type ContentFor<T extends WebhookEventType> = WebhookContentMap[T];
+
+  export interface WebhookEvent<T extends WebhookEventType = WebhookEventType> {
     content: ContentFor<T>;
     id: string;
     occurred_at: number;