@paid-ai/paid-node 1.7.1 → 2.0.0

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

@@ -0,0 +1,359 @@
+/**
+ * Full value model configuration: value types, formulas, events, 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;
+            /** Gates when this value type's number is published to a customer on a value receipt. Evaluated per customer, cumulative since their first signal for this value type, as of the receipt's end date. Until the threshold is met the receipt withholds the figure and shows a 'gathering data' state instead. At least one of minDataPoints or minMonths is required. */
+            maturation?: unknown | 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;
+                        /** Fixed source unit the signal field reports its value in; the engine converts it into the metric's duration unit (targetUnit). Used as the fallback when sourceUnitFromSignal is set but the companion field is missing/invalid. Requires a duration value type. */
+                        sourceUnit?: DerivedFrom.SourceUnit;
+                        /** When true, each event names its own source unit in a "<sourceField>_unit" companion field (e.g. sourceField "time_spent" reads "time_spent_unit"), which must be one of seconds|minutes|hours|days. Takes precedence over sourceUnit; if the companion is absent or invalid it falls back to sourceUnit. If neither resolves, the payload value is discarded and the variable's default is used (the default is stored in the metric's unit and is never converted); the value is never silently treated as seconds. Requires a duration value type. */
+                        sourceUnitFromSignal?: boolean;
+                    }
+                    namespace DerivedFrom {
+                        const TargetUnit: {
+                            readonly Seconds: "seconds";
+                            readonly Minutes: "minutes";
+                            readonly Hours: "hours";
+                            readonly Days: "days";
+                        };
+                        type TargetUnit = (typeof TargetUnit)[keyof typeof TargetUnit];
+                        /** Fixed source unit the signal field reports its value in; the engine converts it into the metric's duration unit (targetUnit). Used as the fallback when sourceUnitFromSignal is set but the companion field is missing/invalid. Requires a duration value type. */
+                        const SourceUnit: {
+                            readonly Seconds: "seconds";
+                            readonly Minutes: "minutes";
+                            readonly Hours: "hours";
+                            readonly Days: "days";
+                        };
+                        type SourceUnit = (typeof SourceUnit)[keyof typeof SourceUnit];
+                    }
+                }
+            }
+            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;
+            /** Per-value-metric formula variable overrides, keyed by value type slug. Scoped to the named metric's formulas only, so a binding event shared with other metrics does not leak these values into them. */
+            valueTypeOverrides?: Record<string, Item.ValueTypeOverrides.Value>;
+            additionalSignals?: Item.AdditionalSignals.Item[];
+            monetaryConversionOverrides?: Record<string, Item.MonetaryConversionOverrides.Value>;
+        }
+        namespace Item {
+            interface Scope {
+                customerIds: 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,148 @@
+"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",
+                        };
+                        /** Fixed source unit the signal field reports its value in; the engine converts it into the metric's duration unit (targetUnit). Used as the fallback when sourceUnitFromSignal is set but the companion field is missing/invalid. Requires a duration value type. */
+                        DerivedFrom.SourceUnit = {
+                            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/ValueReceiptDetail.d.ts

@@ -1,5 +1,6 @@
 export interface ValueReceiptDetail {
     id: string;
+    /** Always "posted": a value receipt is immutable from creation. */
     status: string;
     publicUrlToken: string;
     publicUrl: string;

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

@@ -1,5 +1,6 @@
 export interface ValueReceiptSummary {
     id: string;
+    /** Always "posted": a value receipt is immutable from creation. */
     status: string;
     publicUrlToken: string;
     publicUrl: string;

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

@@ -1,6 +1,8 @@
 export interface ValueReceiptSyncResponse {
     id: string;
+    /** Always "posted". */
     status: string;
     publicUrlToken: string;
     publicUrl: string;
+    generatedAt?: string | null;
 }

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

@@ -0,0 +1,7 @@
+import type * as Paid from "../index.js";
+export interface ViewCustomerUnitsResponse {
+    /** Whether this customer has an active non-root unit, regardless of the requested page or usage. */
+    hasHierarchy: boolean;
+    data: Paid.CustomViewCustomerUnit[];
+    pagination: Paid.Pagination;
+}

package/dist/cjs/api/types/ViewCustomerUnitsResponse.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/ViewDataResponse.d.ts

@@ -0,0 +1,6 @@
+import type * as Paid from "../index.js";
+export interface ViewDataResponse {
+    context?: Paid.CustomViewDataContext;
+    /** 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

@@ -10,8 +10,8 @@ export interface Webhook {
 }
 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 +19,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

@@ -5,8 +5,8 @@ exports.Webhook = void 0;
 var Webhook;
 (function (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 +14,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;
 }