@paid-ai/paid-node 1.7.0 → 1.8.0

package/dist/cjs/api/types/ValueModelContent.d.ts

@@ -0,0 +1,357 @@
+/**
+ * Full value model configuration: value types, formulas, signals, and overrides.
+ */
+export interface ValueModelContent {
+    currency: string;
+    valueTypes: ValueModelContent.ValueTypes.Item[];
+    formulas: ValueModelContent.Formulas.Item[];
+    signals: ValueModelContent.Signals.Item[];
+    segmentTables?: ValueModelContent.SegmentTables.Item[];
+    overrides?: ValueModelContent.Overrides.Item[];
+}
+export declare namespace ValueModelContent {
+    type ValueTypes = ValueTypes.Item[];
+    namespace ValueTypes {
+        interface Item {
+            slug: string;
+            name: string;
+            calculationTimeline: Item.CalculationTimeline.Item[];
+            description?: string | null;
+            longDescription?: string | null;
+            sources?: Item.Sources.Item[] | null;
+            displayOrder?: number | null;
+            color?: string | null;
+            icon?: string | null;
+            category?: Item.Category | null;
+            archivedAt?: string | null;
+        }
+        namespace Item {
+            type CalculationTimeline = CalculationTimeline.Item[];
+            namespace CalculationTimeline {
+                interface Item {
+                    effectiveFrom: string;
+                    calculation: Item.Calculation;
+                }
+                namespace Item {
+                    interface Calculation {
+                        unit: Calculation.Unit;
+                        monetaryConversion?: Calculation.MonetaryConversion;
+                        formulaIds: string[];
+                        signalEventNames: string[];
+                        segmentTableIds: string[];
+                        overrideIds: string[];
+                    }
+                    namespace Calculation {
+                        type Unit = {
+                            type: "monetary";
+                        } | {
+                            type: "duration";
+                            durationUnit: "seconds" | "minutes" | "hours" | "days";
+                        } | {
+                            type: "custom";
+                            unit: string;
+                            unit_display: string;
+                        };
+                        interface MonetaryConversion {
+                            expression: string;
+                            variables?: MonetaryConversion.Variables.Item[];
+                            conditions?: MonetaryConversion.Conditions.Item[];
+                        }
+                        namespace MonetaryConversion {
+                            type Variables = Variables.Item[];
+                            namespace Variables {
+                                interface Item {
+                                    id: string;
+                                    label: string;
+                                    default: number;
+                                }
+                            }
+                            type Conditions = Conditions.Item[];
+                            namespace Conditions {
+                                interface Item {
+                                    field: string;
+                                    operator: Item.Operator;
+                                    value: Item.Value;
+                                    result: Item.Result;
+                                }
+                                namespace Item {
+                                    const Operator: {
+                                        readonly Gte: "gte";
+                                        readonly Gt: "gt";
+                                        readonly Lt: "lt";
+                                        readonly Lte: "lte";
+                                        readonly Eq: "eq";
+                                        readonly Neq: "neq";
+                                        readonly Contains: "contains";
+                                        readonly EqString: "eq_string";
+                                        readonly EqBool: "eq_bool";
+                                    };
+                                    type Operator = (typeof Operator)[keyof typeof Operator];
+                                    type Value = number | string | boolean;
+                                    interface Result {
+                                        type: Result.Type;
+                                        value?: number;
+                                        expression?: string;
+                                    }
+                                    namespace Result {
+                                        const Type: {
+                                            readonly Constant: "constant";
+                                            readonly Expression: "expression";
+                                        };
+                                        type Type = (typeof Type)[keyof typeof Type];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            type Sources = Sources.Item[];
+            namespace Sources {
+                interface Item {
+                    name: string;
+                    url: string;
+                }
+            }
+            const Category: {
+                readonly Hve: "hve";
+                readonly Time: "time";
+                readonly Cost: "cost";
+                readonly Revenue: "revenue";
+                readonly Risk: "risk";
+            };
+            type Category = (typeof Category)[keyof typeof Category];
+        }
+    }
+    type Formulas = Formulas.Item[];
+    namespace Formulas {
+        interface Item {
+            id: string;
+            valueTypeSlug: string;
+            label: string;
+            description?: string;
+            variables: Item.Variables.Item[];
+            expression: string;
+            conditions?: Item.Conditions.Item[];
+            defaultResult?: Item.DefaultResult;
+        }
+        namespace Item {
+            type Variables = Variables.Item[];
+            namespace Variables {
+                interface Item {
+                    id: string;
+                    label: string;
+                    type?: Item.Type;
+                    description?: string;
+                    /** Display-only formatting hint. "percent" renders the variable as a percentage (a stored 0.02 displays as 2%). "duration" renders it as a length of time, stepping down to the largest whole unit (0.75 with formatUnit "hours" displays as "45 minutes") and requires formatUnit. Calculations always use the stored raw value. */
+                    format?: Item.Format;
+                    /** The time unit the stored value is expressed in. Required when format is "duration"; ignored otherwise. */
+                    formatUnit?: Item.FormatUnit;
+                    derivedFrom?: Item.DerivedFrom;
+                }
+                namespace Item {
+                    const Type: {
+                        readonly Number: "number";
+                        readonly String: "string";
+                        readonly Boolean: "boolean";
+                        readonly Duration: "duration";
+                    };
+                    type Type = (typeof Type)[keyof typeof Type];
+                    /** Display-only formatting hint. "percent" renders the variable as a percentage (a stored 0.02 displays as 2%). "duration" renders it as a length of time, stepping down to the largest whole unit (0.75 with formatUnit "hours" displays as "45 minutes") and requires formatUnit. Calculations always use the stored raw value. */
+                    const Format: {
+                        readonly Percent: "percent";
+                        readonly Duration: "duration";
+                    };
+                    type Format = (typeof Format)[keyof typeof Format];
+                    /** The time unit the stored value is expressed in. Required when format is "duration"; ignored otherwise. */
+                    const FormatUnit: {
+                        readonly Seconds: "seconds";
+                        readonly Minutes: "minutes";
+                        readonly Hours: "hours";
+                        readonly Days: "days";
+                    };
+                    type FormatUnit = (typeof FormatUnit)[keyof typeof FormatUnit];
+                    interface DerivedFrom {
+                        sourceField: string;
+                        targetUnit: DerivedFrom.TargetUnit;
+                    }
+                    namespace DerivedFrom {
+                        const TargetUnit: {
+                            readonly Seconds: "seconds";
+                            readonly Minutes: "minutes";
+                            readonly Hours: "hours";
+                            readonly Days: "days";
+                        };
+                        type TargetUnit = (typeof TargetUnit)[keyof typeof TargetUnit];
+                    }
+                }
+            }
+            type Conditions = Conditions.Item[];
+            namespace Conditions {
+                interface Item {
+                    field: string;
+                    operator: Item.Operator;
+                    value: Item.Value;
+                    result: Item.Result;
+                }
+                namespace Item {
+                    const Operator: {
+                        readonly Gte: "gte";
+                        readonly Gt: "gt";
+                        readonly Lt: "lt";
+                        readonly Lte: "lte";
+                        readonly Eq: "eq";
+                        readonly Neq: "neq";
+                        readonly Contains: "contains";
+                        readonly EqString: "eq_string";
+                        readonly EqBool: "eq_bool";
+                    };
+                    type Operator = (typeof Operator)[keyof typeof Operator];
+                    type Value = number | string | boolean;
+                    interface Result {
+                        type: Result.Type;
+                        value?: number;
+                        expression?: string;
+                    }
+                    namespace Result {
+                        const Type: {
+                            readonly Constant: "constant";
+                            readonly Expression: "expression";
+                        };
+                        type Type = (typeof Type)[keyof typeof Type];
+                    }
+                }
+            }
+            interface DefaultResult {
+                type: DefaultResult.Type;
+                value?: number;
+                expression?: string;
+            }
+            namespace DefaultResult {
+                const Type: {
+                    readonly Constant: "constant";
+                    readonly Expression: "expression";
+                };
+                type Type = (typeof Type)[keyof typeof Type];
+            }
+        }
+    }
+    type Signals = Signals.Item[];
+    namespace Signals {
+        interface Item {
+            eventName: string;
+            label: string;
+            formulaId?: string;
+            variableMapping?: Record<string, string>;
+            defaults?: Record<string, Item.Defaults.Value>;
+            segmentTableIds?: string[];
+            description?: string;
+            labels?: string[];
+            tags?: string[];
+        }
+        namespace Item {
+            namespace Defaults {
+                type Value = number | string;
+            }
+        }
+    }
+    type SegmentTables = SegmentTables.Item[];
+    namespace SegmentTables {
+        interface Item {
+            id: string;
+            label: string;
+            segmentKeys: string[];
+            columns: Item.Columns.Item[];
+            rows: Item.Rows.Item[];
+            defaultRow?: Record<string, number>;
+        }
+        namespace Item {
+            type Columns = Columns.Item[];
+            namespace Columns {
+                interface Item {
+                    variableId: string;
+                    label: string;
+                    type: Item.Type;
+                }
+                namespace Item {
+                    const Type: {
+                        readonly Number: "number";
+                    };
+                    type Type = (typeof Type)[keyof typeof Type];
+                }
+            }
+            type Rows = Rows.Item[];
+            namespace Rows {
+                interface Item {
+                    segmentValues: Record<string, string>;
+                    variables: Record<string, number>;
+                }
+            }
+        }
+    }
+    type Overrides = Overrides.Item[];
+    namespace Overrides {
+        interface Item {
+            id: string;
+            label: string;
+            scope: Item.Scope;
+            currency?: string;
+            signalOverrides?: Record<string, Item.SignalOverrides.Value>;
+            /** Per-value-metric formula variable overrides, keyed by value type slug. Scoped to the named metric's formulas only — unlike signalOverrides (keyed by event name), a binding event shared with other metrics does not leak these values into them. When both shapes set the same variable, the value here wins. */
+            valueTypeOverrides?: Record<string, Item.ValueTypeOverrides.Value>;
+            additionalSignals?: Item.AdditionalSignals.Item[];
+            monetaryConversionOverrides?: Record<string, Item.MonetaryConversionOverrides.Value>;
+        }
+        namespace Item {
+            interface Scope {
+                customerIds?: string[];
+                customerGroupIds?: string[];
+            }
+            namespace SignalOverrides {
+                interface Value {
+                    defaults?: Record<string, Value.Defaults.Value>;
+                }
+                namespace Value {
+                    namespace Defaults {
+                        type Value = number | string;
+                    }
+                }
+            }
+            namespace ValueTypeOverrides {
+                interface Value {
+                    /** Formula variable values to apply for this scope's customers, keyed by variable id. Each key must be a variable declared by one of this value type's formulas. */
+                    variables?: Record<string, Value.Variables.Value>;
+                }
+                namespace Value {
+                    namespace Variables {
+                        type Value = number | string;
+                    }
+                }
+            }
+            type AdditionalSignals = AdditionalSignals.Item[];
+            namespace AdditionalSignals {
+                interface Item {
+                    eventName: string;
+                    label: string;
+                    formulaId?: string;
+                    variableMapping?: Record<string, string>;
+                    defaults?: Record<string, Item.Defaults.Value>;
+                    segmentTableIds?: string[];
+                    description?: string;
+                    labels?: string[];
+                    tags?: string[];
+                }
+                namespace Item {
+                    namespace Defaults {
+                        type Value = number | string;
+                    }
+                }
+            }
+            namespace MonetaryConversionOverrides {
+                interface Value {
+                    variables?: Record<string, number>;
+                }
+            }
+        }
+    }
+}

package/dist/cjs/api/types/ValueModelContent.js

@@ -0,0 +1,141 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueModelContent = void 0;
+var ValueModelContent;
+(function (ValueModelContent) {
+    let ValueTypes;
+    (function (ValueTypes) {
+        let Item;
+        (function (Item_1) {
+            let CalculationTimeline;
+            (function (CalculationTimeline) {
+                let Item;
+                (function (Item_2) {
+                    let Calculation;
+                    (function (Calculation) {
+                        let MonetaryConversion;
+                        (function (MonetaryConversion) {
+                            let Conditions;
+                            (function (Conditions) {
+                                let Item;
+                                (function (Item) {
+                                    Item.Operator = {
+                                        Gte: "gte",
+                                        Gt: "gt",
+                                        Lt: "lt",
+                                        Lte: "lte",
+                                        Eq: "eq",
+                                        Neq: "neq",
+                                        Contains: "contains",
+                                        EqString: "eq_string",
+                                        EqBool: "eq_bool",
+                                    };
+                                    let Result;
+                                    (function (Result) {
+                                        Result.Type = {
+                                            Constant: "constant",
+                                            Expression: "expression",
+                                        };
+                                    })(Result = Item.Result || (Item.Result = {}));
+                                })(Item = Conditions.Item || (Conditions.Item = {}));
+                            })(Conditions = MonetaryConversion.Conditions || (MonetaryConversion.Conditions = {}));
+                        })(MonetaryConversion = Calculation.MonetaryConversion || (Calculation.MonetaryConversion = {}));
+                    })(Calculation = Item_2.Calculation || (Item_2.Calculation = {}));
+                })(Item = CalculationTimeline.Item || (CalculationTimeline.Item = {}));
+            })(CalculationTimeline = Item_1.CalculationTimeline || (Item_1.CalculationTimeline = {}));
+            Item_1.Category = {
+                Hve: "hve",
+                Time: "time",
+                Cost: "cost",
+                Revenue: "revenue",
+                Risk: "risk",
+            };
+        })(Item = ValueTypes.Item || (ValueTypes.Item = {}));
+    })(ValueTypes = ValueModelContent.ValueTypes || (ValueModelContent.ValueTypes = {}));
+    let Formulas;
+    (function (Formulas) {
+        let Item;
+        (function (Item_3) {
+            let Variables;
+            (function (Variables) {
+                let Item;
+                (function (Item) {
+                    Item.Type = {
+                        Number: "number",
+                        String: "string",
+                        Boolean: "boolean",
+                        Duration: "duration",
+                    };
+                    /** Display-only formatting hint. "percent" renders the variable as a percentage (a stored 0.02 displays as 2%). "duration" renders it as a length of time, stepping down to the largest whole unit (0.75 with formatUnit "hours" displays as "45 minutes") and requires formatUnit. Calculations always use the stored raw value. */
+                    Item.Format = {
+                        Percent: "percent",
+                        Duration: "duration",
+                    };
+                    /** The time unit the stored value is expressed in. Required when format is "duration"; ignored otherwise. */
+                    Item.FormatUnit = {
+                        Seconds: "seconds",
+                        Minutes: "minutes",
+                        Hours: "hours",
+                        Days: "days",
+                    };
+                    let DerivedFrom;
+                    (function (DerivedFrom) {
+                        DerivedFrom.TargetUnit = {
+                            Seconds: "seconds",
+                            Minutes: "minutes",
+                            Hours: "hours",
+                            Days: "days",
+                        };
+                    })(DerivedFrom = Item.DerivedFrom || (Item.DerivedFrom = {}));
+                })(Item = Variables.Item || (Variables.Item = {}));
+            })(Variables = Item_3.Variables || (Item_3.Variables = {}));
+            let Conditions;
+            (function (Conditions) {
+                let Item;
+                (function (Item) {
+                    Item.Operator = {
+                        Gte: "gte",
+                        Gt: "gt",
+                        Lt: "lt",
+                        Lte: "lte",
+                        Eq: "eq",
+                        Neq: "neq",
+                        Contains: "contains",
+                        EqString: "eq_string",
+                        EqBool: "eq_bool",
+                    };
+                    let Result;
+                    (function (Result) {
+                        Result.Type = {
+                            Constant: "constant",
+                            Expression: "expression",
+                        };
+                    })(Result = Item.Result || (Item.Result = {}));
+                })(Item = Conditions.Item || (Conditions.Item = {}));
+            })(Conditions = Item_3.Conditions || (Item_3.Conditions = {}));
+            let DefaultResult;
+            (function (DefaultResult) {
+                DefaultResult.Type = {
+                    Constant: "constant",
+                    Expression: "expression",
+                };
+            })(DefaultResult = Item_3.DefaultResult || (Item_3.DefaultResult = {}));
+        })(Item = Formulas.Item || (Formulas.Item = {}));
+    })(Formulas = ValueModelContent.Formulas || (ValueModelContent.Formulas = {}));
+    let SegmentTables;
+    (function (SegmentTables) {
+        let Item;
+        (function (Item_4) {
+            let Columns;
+            (function (Columns) {
+                let Item;
+                (function (Item) {
+                    Item.Type = {
+                        Number: "number",
+                    };
+                })(Item = Columns.Item || (Columns.Item = {}));
+            })(Columns = Item_4.Columns || (Item_4.Columns = {}));
+        })(Item = SegmentTables.Item || (SegmentTables.Item = {}));
+    })(SegmentTables = ValueModelContent.SegmentTables || (ValueModelContent.SegmentTables = {}));
+})(ValueModelContent || (exports.ValueModelContent = ValueModelContent = {}));

package/dist/cjs/api/types/ValueModelDetail.d.ts

@@ -0,0 +1,12 @@
+import type * as Paid from "../index.js";
+export interface ValueModelDetail {
+    /** Value model version ID. */
+    id: string;
+    /** Monotonically increasing version number. */
+    version: number;
+    content: Paid.ValueModelContent;
+    createdAt: string;
+    activatedAt: string | null;
+    effectiveFrom: string | null;
+    effectiveTo: string | null;
+}

package/dist/cjs/api/types/ValueModelDetail.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/types/ValueModelSummary.d.ts

@@ -0,0 +1,18 @@
+export interface ValueModelSummary {
+    id: string;
+    version: number;
+    status: ValueModelSummary.Status;
+    createdAt: string;
+    activatedAt: string | null;
+    archivedAt: string | null;
+    effectiveFrom: string | null;
+    effectiveTo: string | null;
+}
+export declare namespace ValueModelSummary {
+    const Status: {
+        readonly Draft: "draft";
+        readonly Active: "active";
+        readonly Archived: "archived";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+}

package/dist/cjs/api/types/ValueModelSummary.js

@@ -0,0 +1,12 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueModelSummary = void 0;
+var ValueModelSummary;
+(function (ValueModelSummary) {
+    ValueModelSummary.Status = {
+        Draft: "draft",
+        Active: "active",
+        Archived: "archived",
+    };
+})(ValueModelSummary || (exports.ValueModelSummary = ValueModelSummary = {}));

package/dist/cjs/api/types/ValueModelVersionListResponse.d.ts

@@ -0,0 +1,5 @@
+import type * as Paid from "../index.js";
+export interface ValueModelVersionListResponse {
+    data: Paid.ValueModelSummary[];
+    pagination: Paid.Pagination;
+}

package/dist/cjs/api/types/ValueModelVersionListResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/types/ValueReceiptSyncResponse.d.ts

@@ -3,4 +3,5 @@ export interface ValueReceiptSyncResponse {
     status: string;
     publicUrlToken: string;
     publicUrl: string;
+    generatedAt?: string | null;
 }

package/dist/cjs/api/types/ViewDataResponse.d.ts

@@ -0,0 +1,4 @@
+export interface ViewDataResponse {
+    /** Result sets keyed by query id. Each value is an array of row objects (column name → value); 64-bit integers are returned as JSON strings to preserve precision. */
+    data: Record<string, Record<string, unknown>[]>;
+}

package/dist/cjs/api/types/ViewDataResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/types/Webhook.d.ts

@@ -12,6 +12,7 @@ export declare namespace Webhook {
     const Name: {
         readonly BillingInvoiceCreated: "billing-invoice-created";
         readonly BillingInvoicePaid: "billing-invoice-paid";
+        readonly BillingInvoicePosted: "billing-invoice-posted";
         readonly BillingCheckoutCreated: "billing-checkout-created";
         readonly BillingCheckoutCompleted: "billing-checkout-completed";
         readonly BillingCheckoutExpired: "billing-checkout-expired";
@@ -19,6 +20,7 @@ export declare namespace Webhook {
         readonly BillingPaymentFailed: "billing-payment-failed";
         readonly BillingCreditsDepleted: "billing-credits-depleted";
         readonly BillingOverageIncurred: "billing-overage-incurred";
+        readonly BillingCreditCapReached: "billing-credit-cap-reached";
     };
     type Name = (typeof Name)[keyof typeof Name];
 }

package/dist/cjs/api/types/Webhook.js

@@ -7,6 +7,7 @@ var Webhook;
     Webhook.Name = {
         BillingInvoiceCreated: "billing-invoice-created",
         BillingInvoicePaid: "billing-invoice-paid",
+        BillingInvoicePosted: "billing-invoice-posted",
         BillingCheckoutCreated: "billing-checkout-created",
         BillingCheckoutCompleted: "billing-checkout-completed",
         BillingCheckoutExpired: "billing-checkout-expired",
@@ -14,5 +15,6 @@ var Webhook;
         BillingPaymentFailed: "billing-payment-failed",
         BillingCreditsDepleted: "billing-credits-depleted",
         BillingOverageIncurred: "billing-overage-incurred",
+        BillingCreditCapReached: "billing-credit-cap-reached",
     };
 })(Webhook || (exports.Webhook = Webhook = {}));

package/dist/cjs/api/types/WebhookListResponse.d.ts

@@ -1,4 +1,6 @@
 import type * as Paid from "../index.js";
 export interface WebhookListResponse {
     data: Paid.Webhook[];
+    /** True when the organization has generated a webhook signing secret at least once. */
+    signingSecretConfigured: boolean;
 }

package/dist/cjs/api/types/WebhookUpdateResponse.d.ts

@@ -0,0 +1,28 @@
+import type * as Paid from "../index.js";
+export interface WebhookUpdateResponse {
+    id: string;
+    name: WebhookUpdateResponse.Name;
+    description: string;
+    enabled: boolean;
+    url: string | null;
+    lastSentAt: string | null;
+    lastStatus: Paid.WebhookDeliveryStatus | null;
+    /** Included on the response of the first save that produced a signing key for this organization (when no webhook had a key yet). Store it now — subsequent reads will not return it; rotate to mint a new one if you lose it. */
+    signingSecret?: string;
+}
+export declare namespace WebhookUpdateResponse {
+    const Name: {
+        readonly BillingInvoiceCreated: "billing-invoice-created";
+        readonly BillingInvoicePaid: "billing-invoice-paid";
+        readonly BillingInvoicePosted: "billing-invoice-posted";
+        readonly BillingCheckoutCreated: "billing-checkout-created";
+        readonly BillingCheckoutCompleted: "billing-checkout-completed";
+        readonly BillingCheckoutExpired: "billing-checkout-expired";
+        readonly BillingPaymentSucceeded: "billing-payment-succeeded";
+        readonly BillingPaymentFailed: "billing-payment-failed";
+        readonly BillingCreditsDepleted: "billing-credits-depleted";
+        readonly BillingOverageIncurred: "billing-overage-incurred";
+        readonly BillingCreditCapReached: "billing-credit-cap-reached";
+    };
+    type Name = (typeof Name)[keyof typeof Name];
+}

package/dist/cjs/api/types/WebhookUpdateResponse.js

@@ -0,0 +1,20 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookUpdateResponse = void 0;
+var WebhookUpdateResponse;
+(function (WebhookUpdateResponse) {
+    WebhookUpdateResponse.Name = {
+        BillingInvoiceCreated: "billing-invoice-created",
+        BillingInvoicePaid: "billing-invoice-paid",
+        BillingInvoicePosted: "billing-invoice-posted",
+        BillingCheckoutCreated: "billing-checkout-created",
+        BillingCheckoutCompleted: "billing-checkout-completed",
+        BillingCheckoutExpired: "billing-checkout-expired",
+        BillingPaymentSucceeded: "billing-payment-succeeded",
+        BillingPaymentFailed: "billing-payment-failed",
+        BillingCreditsDepleted: "billing-credits-depleted",
+        BillingOverageIncurred: "billing-overage-incurred",
+        BillingCreditCapReached: "billing-credit-cap-reached",
+    };
+})(WebhookUpdateResponse || (exports.WebhookUpdateResponse = WebhookUpdateResponse = {}));