@commet/node 4.5.0 → 5.0.0

package/dist/index.d.ts

@@ -71,17 +71,21 @@ type CommetClientOptions = {
     retries?: number;
     telemetry?: boolean;
 };
-/** @deprecated Use CommetClientOptions */
-type CommetConfig = CommetClientOptions;
 interface ApiResponse<T = unknown> {
     success: boolean;
     data?: T;
-    code?: string;
-    message?: string;
-    details?: unknown;
+    error?: ApiErrorDetail;
     hasMore?: boolean;
     nextCursor?: string;
 }
+interface ApiErrorDetail {
+    type: string;
+    code: string;
+    message: string;
+    param?: string;
+    details?: unknown;
+    doc_url?: string;
+}
 interface PaginatedResponse<T> {
     data: T[];
     hasMore: boolean;
@@ -102,7 +106,10 @@ declare class CommetAPIError extends CommetError {
     statusCode: number;
     code?: string | undefined;
     details?: unknown | undefined;
-    constructor(message: string, statusCode: number, code?: string | undefined, details?: unknown | undefined);
+    type?: string;
+    param?: string;
+    docUrl?: string;
+    constructor(message: string, statusCode: number, code?: string | undefined, details?: unknown | undefined, errorDetail?: ApiErrorDetail);
 }
 declare class CommetValidationError extends CommetError {
     validationErrors: Record<string, string[]>;
@@ -142,11 +149,12 @@ declare class CommetHTTPClient {
     private telemetryEnabled;
     private lastRequestMetrics;
     constructor(config: CommetClientOptions);
-    get<T = unknown>(endpoint: string, params?: Record<string, unknown>, options?: RequestOptions): Promise<ApiResponse<T>>;
+    get<T = unknown>(endpoint: string, params?: Record<string, unknown> | object, options?: RequestOptions): Promise<ApiResponse<T>>;
     post<T = unknown>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<ApiResponse<T>>;
     put<T = unknown>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<ApiResponse<T>>;
     delete<T = unknown>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<ApiResponse<T>>;
     private resolveApiVersion;
+    private static readonly BODY_METHODS;
     private request;
     /**
      * Execute real API request with retry logic
@@ -156,9 +164,6 @@ declare class CommetHTTPClient {
      * Build full URL from endpoint and params
      */
     private buildURL;
-    /**
-     * Generate idempotency key
-     */
     private generateIdempotencyKey;
     /**
      * Sleep for specified milliseconds
@@ -166,14 +171,290 @@ declare class CommetHTTPClient {
     private sleep;
 }
 
-interface FeatureParams {
+interface ActiveAddon {
+    object: "addon";
+    livemode: boolean;
+    slug: string;
+    name: string;
+    basePrice: number;
+    featureCode: string;
+    featureName: string;
+    featureType: string;
+    consumptionModel: string | null;
+    activatedAt: string;
+}
+interface ListActiveAddonsParams {
+    customerId: CustomerID;
+}
+interface AddonBase {
+    id: string;
+    object: "addon";
+    livemode: boolean;
+    name: string;
+    slug: string;
+    description: string | null;
+    basePrice: number;
+    featureCode: string;
+    featureName: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface BooleanAddon extends AddonBase {
+    consumptionModel: "boolean";
+    includedUnits: null;
+    overageRate: null;
+    creditCost: null;
+}
+interface MeteredAddon extends AddonBase {
+    consumptionModel: "metered";
+    includedUnits: number;
+    overageRate: number;
+    creditCost: null;
+}
+interface CreditsAddon extends AddonBase {
+    consumptionModel: "credits";
+    includedUnits: null;
+    overageRate: null;
+    creditCost: number;
+}
+interface BalanceAddon extends AddonBase {
+    consumptionModel: "balance";
+    includedUnits: null;
+    overageRate: number;
+    creditCost: null;
+}
+type Addon = BooleanAddon | MeteredAddon | CreditsAddon | BalanceAddon;
+interface ListAddonsParams {
+    limit?: number;
+    cursor?: string;
+}
+interface GetAddonParams {
+    id: string;
+}
+interface CreateAddonBase {
+    name: string;
+    description?: string;
+    basePrice: number;
+    featureId: string;
+}
+interface CreateBooleanAddonParams extends CreateAddonBase {
+    consumptionModel: "boolean";
+}
+interface CreateMeteredAddonParams extends CreateAddonBase {
+    consumptionModel: "metered";
+    includedUnits: number;
+    overageRate: number;
+}
+interface CreateCreditsAddonParams extends CreateAddonBase {
+    consumptionModel: "credits";
+    creditCost: number;
+}
+interface CreateBalanceAddonParams extends CreateAddonBase {
+    consumptionModel: "balance";
+    overageRate: number;
+}
+type CreateAddonParams = CreateBooleanAddonParams | CreateMeteredAddonParams | CreateCreditsAddonParams | CreateBalanceAddonParams;
+interface UpdateAddonParams {
+    id: string;
+    name?: string;
+    description?: string;
+    basePrice?: number;
+    includedUnits?: number;
+    overageRate?: number;
+}
+interface DeleteAddonParams {
+    id: string;
+}
+declare class AddonsResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    listActive(params: ListActiveAddonsParams, options?: RequestOptions): Promise<ApiResponse<ActiveAddon[]>>;
+    list(params?: ListAddonsParams, options?: RequestOptions): Promise<ApiResponse<Addon[]>>;
+    get(params: GetAddonParams, options?: RequestOptions): Promise<ApiResponse<Addon>>;
+    create(params: CreateAddonParams, options?: RequestOptions): Promise<ApiResponse<Addon>>;
+    update(params: UpdateAddonParams, options?: RequestOptions): Promise<ApiResponse<Addon>>;
+    /** Fails if addon has active subscriptions. */
+    delete(params: DeleteAddonParams, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        deleted: true;
+    }>>;
+}
+
+interface ApiKey {
+    id: string;
+    object: "api_key";
+    livemode: boolean;
+    name: string;
+    prefix: string;
+    expiresAt: string | null;
+    lastUsedAt: string | null;
+    createdAt: string;
+}
+interface ApiKeyCreated extends ApiKey {
+    apiKey: string;
+}
+interface ListApiKeysParams {
+    limit?: number;
+    cursor?: string;
+}
+interface CreateApiKeyParams {
+    name: string;
+    expiresInDays?: number;
+}
+interface DeleteApiKeyParams {
+    id: string;
+}
+declare class ApiKeysResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    list(params?: ListApiKeysParams): Promise<ApiResponse<ApiKey[]>>;
+    /** Response includes full `apiKey` which is only returned once. */
+    create(params: CreateApiKeyParams, options?: RequestOptions): Promise<ApiResponse<ApiKeyCreated>>;
+    delete(params: DeleteApiKeyParams, options?: RequestOptions): Promise<ApiResponse<void>>;
+}
+
+interface CreditPack {
+    id: string;
+    object: "credit_pack";
+    livemode: boolean;
+    name: string;
+    description: string | null;
+    credits: number;
+    price: number;
+    currency: string;
+}
+interface CreditPackDetail {
+    id: string;
+    object: "credit_pack";
+    livemode: boolean;
+    name: string;
+    description: string | null;
+    credits: number;
+    price: number;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateCreditPackParams {
+    name: string;
+    description?: string;
+    credits: number;
+    price: number;
+    isActive?: boolean;
+}
+interface UpdateCreditPackParams {
+    id: string;
+    name?: string;
+    description?: string;
+    credits?: number;
+    price?: number;
+    isActive?: boolean;
+}
+interface DeleteCreditPackParams {
+    id: string;
+}
+declare class CreditPacksResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    list(): Promise<ApiResponse<CreditPack[]>>;
+    create(params: CreateCreditPackParams, options?: RequestOptions): Promise<ApiResponse<CreditPackDetail>>;
+    update(params: UpdateCreditPackParams, options?: RequestOptions): Promise<ApiResponse<CreditPackDetail>>;
+    delete(params: DeleteCreditPackParams, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        deleted: true;
+    }>>;
+}
+
+interface Customer {
+    id: CustomerID;
+    object: "customer";
+    livemode: boolean;
+    organizationId: string;
+    fullName?: string;
+    domain?: string;
+    website?: string;
+    billingEmail: string;
+    timezone?: string;
+    language?: string;
+    industry?: string;
+    employeeCount?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CustomerAddress {
+    line1: string;
+    line2?: string;
+    city: string;
+    state?: string;
+    postalCode: string;
+    country: string;
+}
+interface CreateParams {
+    email: string;
+    id?: string;
+    fullName?: string;
+    domain?: string;
+    website?: string;
+    timezone?: string;
+    language?: string;
+    industry?: string;
+    metadata?: Record<string, unknown>;
+    address?: CustomerAddress;
+}
+interface GetCustomerParams {
+    id: CustomerID;
+}
+interface UpdateParams {
+    id: CustomerID;
+    email?: string;
+    fullName?: string;
+    domain?: string;
+    website?: string;
+    timezone?: string;
+    language?: string;
+    industry?: string;
+    metadata?: Record<string, unknown>;
+    address?: CustomerAddress;
+}
+interface ListCustomersParams extends ListParams {
+    search?: string;
+}
+interface BatchResult {
+    successful: Customer[];
+    failed: Array<{
+        index: number;
+        error: string;
+        data: CreateParams;
+    }>;
+}
+declare class CustomersResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    /** Idempotent when `id` is provided — returns existing customer instead of duplicating. */
+    create(params: CreateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
+    createBatch(params: {
+        customers: CreateParams[];
+    }, options?: RequestOptions): Promise<ApiResponse<BatchResult>>;
+    get(params: GetCustomerParams): Promise<ApiResponse<Customer>>;
+    update(params: UpdateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
+    list(params?: ListCustomersParams): Promise<ApiResponse<Customer[]>>;
+}
+
+interface GetFeatureParams {
+    customerId: CustomerID;
+    code: string;
+}
+interface CanUseFeatureParams {
     customerId: CustomerID;
     code: string;
 }
-type GetFeatureParams = FeatureParams;
-type CheckFeatureParams = FeatureParams;
-type CanUseFeatureParams = FeatureParams;
+interface ListFeaturesParams {
+    customerId: CustomerID;
+}
 interface FeatureAccess {
+    object: "feature";
+    livemode: boolean;
     code: string;
     name: string;
     type: "boolean" | "usage" | "seats";
@@ -192,99 +473,231 @@ interface CanUseResult {
     willBeCharged: boolean;
     reason?: string;
 }
-interface CheckResult {
-    allowed: boolean;
+interface Feature {
+    id: string;
+    object: "feature";
+    livemode: boolean;
+    name: string;
+    code: string;
+    type: "boolean" | "usage" | "seats";
+    description: string | null;
+    unitName: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateFeatureParams {
+    code: string;
+    name: string;
+    type: "boolean" | "usage" | "seats";
+    description?: string;
+    unitName?: string;
+}
+interface UpdateFeatureParams {
+    code: string;
+    name?: string;
+    description?: string;
+    unitName?: string;
+}
+interface DeleteFeatureParams {
+    code: string;
 }
 declare class FeaturesResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
     get(params: GetFeatureParams, options?: RequestOptions): Promise<ApiResponse<FeatureAccess>>;
-    check(params: CheckFeatureParams, options?: RequestOptions): Promise<ApiResponse<CheckResult>>;
+    /** Checks if the customer can consume one more unit — returns billing impact and reason if blocked. */
     canUse(params: CanUseFeatureParams, options?: RequestOptions): Promise<ApiResponse<CanUseResult>>;
-    list(customerId: CustomerID, options?: RequestOptions): Promise<ApiResponse<FeatureAccess[]>>;
+    list(params: ListFeaturesParams, options?: RequestOptions): Promise<ApiResponse<FeatureAccess[]>>;
+    create(params: CreateFeatureParams, options?: RequestOptions): Promise<ApiResponse<Feature>>;
+    update(params: UpdateFeatureParams, options?: RequestOptions): Promise<ApiResponse<Feature>>;
+    /** Fails if feature is attached to active plans or has an active addon. */
+    delete(params: DeleteFeatureParams, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        deleted: true;
+    }>>;
 }
 
-interface PortalAccess {
-    success: boolean;
-    message: string;
-    portalUrl: string;
+interface InvoiceLineItem {
+    lineType: string;
+    featureName: string | null;
+    description: string | null;
+    quantity: number;
+    unitAmount: number;
+    amount: number;
+    includedAmount: number | null;
+    usedAmount: number | null;
+    overageAmount: number | null;
+    discountType: string | null;
+    discountValue: number | null;
+    discountName: string | null;
+    chargeType: string | null;
+}
+interface InvoiceListItem {
+    id: string;
+    object: "invoice";
+    livemode: boolean;
+    customerId: string;
+    subscriptionId: string | null;
+    invoiceNumber: string;
+    status: string;
+    invoiceType: string;
+    currency: string;
+    subtotal: number;
+    discountAmount: number;
+    taxAmount: number;
+    total: number;
+    periodStart: string | null;
+    periodEnd: string | null;
+    issueDate: string;
+    dueDate: string | null;
+    memo: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
 }
-interface GetUrlByCustomerId {
-    customerId: CustomerID;
-    email?: never;
+interface InvoiceDetail extends InvoiceListItem {
+    creditApplied: number;
+    planName: string | null;
+    poNumber: string | null;
+    reference: string | null;
+    lineItems: InvoiceLineItem[];
 }
-interface GetUrlByEmail {
-    email: string;
-    customerId?: never;
+interface InvoiceDownloadResult {
+    url: string;
+    expiresAt: string;
 }
-type GetUrlParams = GetUrlByCustomerId | GetUrlByEmail;
-declare class PortalResource {
+interface InvoiceSendResult {
+    sent: boolean;
+    sentAt: string;
+}
+interface InvoiceStatusResult {
+    id: string;
+    status: string;
+    updatedAt: string;
+}
+interface CreateAdjustmentResult {
+    id: string;
+    object: "invoice";
+    livemode: boolean;
+    customerId: string;
+    invoiceNumber: string;
+    status: string;
+    invoiceType: string;
+    currency: string;
+    subtotal: number;
+    taxAmount: number;
+    total: number;
+    issueDate: string;
+    dueDate: string | null;
+    memo: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ListInvoicesParams {
+    customerId?: string;
+    status?: string;
+    subscriptionId?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface GetInvoiceParams {
+    id: string;
+}
+interface CreateAdjustmentParams {
+    customerId: string;
+    amount: number;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+interface GetDownloadUrlParams {
+    id: string;
+}
+interface SendInvoiceParams {
+    id: string;
+}
+interface UpdateInvoiceStatusParams {
+    id: string;
+    status: string;
+}
+declare class InvoicesResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    getUrl(params: GetUrlParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
+    list(params?: ListInvoicesParams): Promise<ApiResponse<InvoiceListItem[]>>;
+    get(params: GetInvoiceParams): Promise<ApiResponse<InvoiceDetail>>;
+    /** Negative amount creates a credit. */
+    createAdjustment(params: CreateAdjustmentParams, options?: RequestOptions): Promise<ApiResponse<CreateAdjustmentResult>>;
+    /** Signed URL, expires after 7 days. */
+    getDownloadUrl(params: GetDownloadUrlParams): Promise<ApiResponse<InvoiceDownloadResult>>;
+    send(params: SendInvoiceParams, options?: RequestOptions): Promise<ApiResponse<InvoiceSendResult>>;
+    /** Only outstanding invoices can be changed to paid or void. */
+    updateStatus(params: UpdateInvoiceStatusParams, options?: RequestOptions): Promise<ApiResponse<InvoiceStatusResult>>;
 }
 
-interface SeatEvent {
+interface PlanGroup {
     id: string;
-    organizationId: string;
-    customerId: CustomerID;
-    featureCode: string;
-    /** @deprecated Use featureCode */
-    seatType: string;
-    eventType: "add" | "remove" | "set";
-    quantity: number;
-    previousBalance?: number;
-    newBalance: number;
-    ts: string;
+    object: "plan_group";
+    livemode: boolean;
+    name: string;
+    description: string | null;
+    isPublic: boolean;
     createdAt: string;
+    updatedAt: string;
 }
-interface SeatBalance {
-    current: number;
-    asOf: string;
+interface PlanGroupDetail extends PlanGroup {
+    plans: Array<{
+        id: string;
+        code: string;
+        name: string;
+        sortOrder: number;
+    }>;
 }
-interface AddParams {
-    customerId: CustomerID;
-    featureCode?: string;
-    /** @deprecated Use featureCode instead */
-    seatType?: string;
-    count: number;
+interface ListPlanGroupsParams {
+    limit?: number;
+    cursor?: string;
 }
-interface RemoveParams {
-    customerId: CustomerID;
-    featureCode?: string;
-    /** @deprecated Use featureCode instead */
-    seatType?: string;
-    count: number;
+interface GetPlanGroupParams {
+    id: string;
 }
-interface SetParams {
-    customerId: CustomerID;
-    featureCode?: string;
-    /** @deprecated Use featureCode instead */
-    seatType?: string;
-    count: number;
+interface CreatePlanGroupParams {
+    name: string;
+    description?: string;
+    isPublic?: boolean;
 }
-interface SetAllParams {
-    customerId: CustomerID;
-    seats: Record<string, number>;
+interface UpdatePlanGroupParams {
+    id: string;
+    name?: string;
+    description?: string;
+    isPublic?: boolean;
 }
-interface GetBalanceParams {
-    customerId: CustomerID;
-    featureCode?: string;
-    /** @deprecated Use featureCode instead */
-    seatType?: string;
+interface DeletePlanGroupParams {
+    id: string;
 }
-interface GetAllBalancesParams {
-    customerId: CustomerID;
+interface AddPlanToGroupParams {
+    id: string;
+    planId: string;
+    sortOrder?: number;
 }
-declare class SeatsResource {
+interface RemovePlanFromGroupParams {
+    id: string;
+    planId: string;
+}
+interface ReorderPlansParams {
+    id: string;
+    planIds: string[];
+}
+declare class PlanGroupsResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    add(params: AddParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
-    remove(params: RemoveParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
-    set(params: SetParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
-    setAll(params: SetAllParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent[]>>;
-    getBalance(params: GetBalanceParams): Promise<ApiResponse<SeatBalance>>;
-    getAllBalances(params: GetAllBalancesParams): Promise<ApiResponse<Record<string, SeatBalance>>>;
+    list(params?: ListPlanGroupsParams): Promise<ApiResponse<PlanGroup[]>>;
+    get(params: GetPlanGroupParams): Promise<ApiResponse<PlanGroupDetail>>;
+    create(params: CreatePlanGroupParams, options?: RequestOptions): Promise<ApiResponse<PlanGroup>>;
+    update(params: UpdatePlanGroupParams, options?: RequestOptions): Promise<ApiResponse<PlanGroup>>;
+    /** Plans in the group are unlinked, not deleted. */
+    delete(params: DeletePlanGroupParams, options?: RequestOptions): Promise<ApiResponse<void>>;
+    addPlan(params: AddPlanToGroupParams, options?: RequestOptions): Promise<ApiResponse<PlanGroupDetail>>;
+    removePlan(params: RemovePlanFromGroupParams, options?: RequestOptions): Promise<ApiResponse<void>>;
+    reorderPlans(params: ReorderPlansParams, options?: RequestOptions): Promise<ApiResponse<PlanGroupDetail>>;
 }
 
 type PlanID = `plan_${string}`;
@@ -309,6 +722,8 @@ interface PlanFeature {
 }
 interface Plan {
     id: PlanID;
+    object: "plan";
+    livemode: boolean;
     code: string;
     name: string;
     description: string | null;
@@ -341,6 +756,8 @@ interface PlanDetailFeature extends PlanFeature {
 }
 interface PlanDetail {
     id: PlanID;
+    object: "plan";
+    livemode: boolean;
     code: string;
     name: string;
     description: string | null;
@@ -355,36 +772,334 @@ interface PlanDetail {
 interface ListPlansParams extends ListParams {
     includePrivate?: boolean;
 }
-/**
- * Plans resource for listing available plans
- */
+interface PlanManage {
+    id: string;
+    object: "plan";
+    livemode: boolean;
+    name: string;
+    code: string;
+    description: string | null;
+    consumptionModel: string | null;
+    isPublic: boolean;
+    isDefault: boolean;
+    isFree: boolean;
+    blockOnExhaustion: boolean;
+    sortOrder: number;
+    planGroupId: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PlanFeatureManageBase {
+    planId: string;
+    featureId: string;
+    enabled: boolean;
+    includedAmount: number | null;
+    unlimited: boolean;
+    overageEnabled: boolean;
+    creditsPerUnit: number | null;
+}
+interface FixedPricingFeatureManage extends PlanFeatureManageBase {
+    pricingMode: "fixed";
+    overageUnitPrice: number | null;
+    margin: null;
+}
+interface AiModelPricingFeatureManage extends PlanFeatureManageBase {
+    pricingMode: "ai_model";
+    margin: number;
+    overageUnitPrice: null;
+}
+type PlanFeatureManage = FixedPricingFeatureManage | AiModelPricingFeatureManage;
+interface PlanPriceManage {
+    id: string;
+    object: "plan_price";
+    livemode: boolean;
+    planId: string;
+    billingInterval: BillingInterval;
+    price: number;
+    isDefault: boolean;
+    trialDays: number;
+    includedBalance: number | null;
+    includedCredits: number | null;
+    introOfferEnabled: boolean;
+    introOfferDiscountType: "percentage" | "amount" | null;
+    introOfferDiscountValue: number | null;
+    introOfferDurationCycles: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RegionalPriceResult {
+    priceId: string;
+    overrides: Array<{
+        currency: string;
+        price: number;
+    }>;
+}
+interface DeleteResult {
+    id: string;
+    deleted: true;
+}
+interface RemoveResult {
+    id: string;
+    removed: true;
+}
+interface CreatePlanParams {
+    name: string;
+    code: string;
+    description?: string;
+    consumptionModel?: "metered" | "credits" | "balance";
+    isPublic?: boolean;
+    isFree?: boolean;
+    blockOnExhaustion?: boolean;
+    planGroupId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UpdatePlanParams {
+    id: string;
+    name?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    isPublic?: boolean;
+}
+interface DeletePlanParams {
+    id: string;
+}
+interface SetVisibilityParams {
+    id: string;
+    isPublic: boolean;
+}
+interface AddPlanFeatureBase {
+    planId: string;
+    featureId: string;
+    enabled?: boolean;
+    includedAmount?: number;
+    unlimited?: boolean;
+    overageEnabled?: boolean;
+    creditsPerUnit?: number | null;
+}
+interface AddFixedPricingFeatureParams extends AddPlanFeatureBase {
+    pricingMode?: "fixed";
+    overageUnitPrice?: number;
+}
+interface AddAiModelPricingFeatureParams extends AddPlanFeatureBase {
+    pricingMode: "ai_model";
+    margin: number;
+}
+type AddPlanFeatureParams = AddFixedPricingFeatureParams | AddAiModelPricingFeatureParams;
+interface UpdatePlanFeatureBase {
+    planId: string;
+    featureId: string;
+    enabled?: boolean;
+    includedAmount?: number;
+    unlimited?: boolean;
+    overageEnabled?: boolean;
+    creditsPerUnit?: number | null;
+}
+interface UpdateFixedPricingFeatureParams extends UpdatePlanFeatureBase {
+    pricingMode?: "fixed";
+    overageUnitPrice?: number;
+}
+interface UpdateAiModelPricingFeatureParams extends UpdatePlanFeatureBase {
+    pricingMode: "ai_model";
+    margin?: number;
+}
+type UpdatePlanFeatureParams = UpdateFixedPricingFeatureParams | UpdateAiModelPricingFeatureParams;
+interface RemovePlanFeatureParams {
+    planId: string;
+    featureId: string;
+}
+interface AddPlanPriceParams {
+    planId: string;
+    billingInterval: BillingInterval;
+    price: number;
+    trialDays?: number;
+    isDefault?: boolean;
+    includedBalance?: number;
+    includedCredits?: number;
+    introOfferEnabled?: boolean;
+    introOfferDiscountType?: "percentage" | "amount";
+    introOfferDiscountValue?: number;
+    introOfferDurationCycles?: number;
+}
+interface UpdatePlanPriceParams {
+    planId: string;
+    priceId: string;
+    price?: number;
+    isDefault?: boolean;
+    trialDays?: number;
+    includedBalance?: number;
+    includedCredits?: number;
+    introOfferEnabled?: boolean;
+    introOfferDiscountType?: "percentage" | "amount" | null;
+    introOfferDiscountValue?: number | null;
+    introOfferDurationCycles?: number | null;
+}
+interface DeletePlanPriceParams {
+    planId: string;
+    priceId: string;
+}
+interface SetDefaultPriceParams {
+    planId: string;
+    priceId: string;
+}
+interface SetRegionalPricesParams {
+    planId: string;
+    priceId: string;
+    overrides: Array<{
+        currency: string;
+        price: number;
+    }>;
+}
+interface DeleteRegionalPricesParams {
+    planId: string;
+    priceId: string;
+}
 declare class PlansResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    /**
-     * List all available plans
-     *
-     * @example
-     * ```typescript
-     * // List public plans
-     * const plans = await commet.plans.list();
-     *
-     * // Include private plans
-     * const allPlans = await commet.plans.list({ includePrivate: true });
-     * ```
-     */
     list(params?: ListPlansParams): Promise<ApiResponse<Plan[]>>;
-    /**
-     * Get a specific plan by code
-     *
-     * @example
-     * ```typescript
-     * const plan = await commet.plans.get('pro');
-     * console.log(plan.data.name); // "Pro"
-     * console.log(plan.data.prices); // [{ billingInterval: 'monthly', price: 9900 }]
-     * ```
-     */
-    get(planCode: string): Promise<ApiResponse<PlanDetail>>;
+    get(params: {
+        id: string;
+    }): Promise<ApiResponse<PlanDetail>>;
+    create(params: CreatePlanParams, options?: RequestOptions): Promise<ApiResponse<PlanManage>>;
+    update(params: UpdatePlanParams, options?: RequestOptions): Promise<ApiResponse<PlanManage>>;
+    delete(params: DeletePlanParams, options?: RequestOptions): Promise<ApiResponse<DeleteResult>>;
+    setVisibility(params: SetVisibilityParams, options?: RequestOptions): Promise<ApiResponse<PlanManage>>;
+    addFeature(params: AddPlanFeatureParams, options?: RequestOptions): Promise<ApiResponse<PlanFeatureManage>>;
+    updateFeature(params: UpdatePlanFeatureParams, options?: RequestOptions): Promise<ApiResponse<PlanFeatureManage>>;
+    removeFeature(params: RemovePlanFeatureParams, options?: RequestOptions): Promise<ApiResponse<RemoveResult>>;
+    addPrice(params: AddPlanPriceParams, options?: RequestOptions): Promise<ApiResponse<PlanPriceManage>>;
+    updatePrice(params: UpdatePlanPriceParams, options?: RequestOptions): Promise<ApiResponse<PlanPriceManage>>;
+    deletePrice(params: DeletePlanPriceParams, options?: RequestOptions): Promise<ApiResponse<DeleteResult>>;
+    setDefaultPrice(params: SetDefaultPriceParams, options?: RequestOptions): Promise<ApiResponse<PlanPriceManage>>;
+    setRegionalPrices(params: SetRegionalPricesParams, options?: RequestOptions): Promise<ApiResponse<RegionalPriceResult>>;
+    deleteRegionalPrices(params: DeleteRegionalPricesParams, options?: RequestOptions): Promise<ApiResponse<DeleteResult>>;
+}
+
+interface PortalAccess {
+    success: boolean;
+    message: string;
+    portalUrl: string;
+}
+interface GetUrlByCustomerId {
+    customerId: CustomerID;
+    email?: never;
+}
+interface GetUrlByEmail {
+    email: string;
+    customerId?: never;
+}
+type GetUrlParams = GetUrlByCustomerId | GetUrlByEmail;
+declare class PortalResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    getUrl(params: GetUrlParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
+}
+
+interface PromoCode {
+    id: string;
+    object: "promo_code";
+    livemode: boolean;
+    code: string;
+    discountType: "percentage" | "amount";
+    discountValue: number;
+    durationCycles: number | null;
+    maxRedemptions: number | null;
+    expiresAt: string | null;
+    active: boolean;
+    redemptionCount: number;
+    createdAt: string;
+}
+interface PromoCodeDetail extends PromoCode {
+    updatedAt: string;
+}
+interface ListPromoCodesParams {
+    limit?: number;
+    cursor?: string;
+}
+interface GetPromoCodeParams {
+    id: string;
+}
+interface CreatePromoCodeParams {
+    code: string;
+    discountType: "percentage" | "amount";
+    discountValue: number;
+    durationCycles?: number;
+    maxRedemptions?: number;
+    expiresAt?: string;
+    planIds?: string[];
+}
+interface UpdatePromoCodeParams {
+    id: string;
+    maxRedemptions?: number;
+    expiresAt?: string;
+    active?: boolean;
+    planIds?: string[];
+}
+declare class PromoCodesResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    list(params?: ListPromoCodesParams): Promise<ApiResponse<PromoCode[]>>;
+    get(params: GetPromoCodeParams): Promise<ApiResponse<PromoCodeDetail>>;
+    create(params: CreatePromoCodeParams, options?: RequestOptions): Promise<ApiResponse<PromoCode>>;
+    update(params: UpdatePromoCodeParams, options?: RequestOptions): Promise<ApiResponse<PromoCodeDetail>>;
+}
+
+interface SeatEvent {
+    id: string;
+    object: "seat";
+    livemode: boolean;
+    organizationId: string;
+    customerId: CustomerID;
+    featureCode: string;
+    eventType: "add" | "remove" | "set";
+    quantity: number;
+    previousBalance?: number;
+    newBalance: number;
+    ts: string;
+    createdAt: string;
+}
+interface SeatBalance {
+    current: number;
+    asOf: string;
+}
+interface AddSeatsParams {
+    customerId: CustomerID;
+    featureCode: string;
+    count?: number;
+}
+interface RemoveSeatsParams {
+    customerId: CustomerID;
+    featureCode: string;
+    count?: number;
+}
+interface SetSeatsParams {
+    customerId: CustomerID;
+    featureCode: string;
+    count: number;
+}
+interface SetAllSeatsParams {
+    customerId: CustomerID;
+    seats: Record<string, number>;
+}
+interface GetBalanceParams {
+    customerId: CustomerID;
+    featureCode: string;
+}
+interface GetAllBalancesParams {
+    customerId: CustomerID;
+}
+declare class SeatsResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    /** Prorates charges for the current billing period. */
+    add(params: AddSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
+    /** Removal takes effect at the end of the billing period. */
+    remove(params: RemoveSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
+    set(params: SetSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
+    setAll(params: SetAllSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent[]>>;
+    getBalance(params: GetBalanceParams): Promise<ApiResponse<SeatBalance>>;
+    getAllBalances(params: GetAllBalancesParams): Promise<ApiResponse<Record<string, SeatBalance>>>;
 }
 
 type SubscriptionStatus = "draft" | "pending_payment" | "trialing" | "active" | "paused" | "past_due" | "canceled" | "expired";
@@ -424,6 +1139,8 @@ interface DiscountSummary {
 type ConsumptionModel = "metered" | "credits" | "balance";
 interface ActiveSubscription {
     id: string;
+    object: "subscription";
+    livemode: boolean;
     customerId: string;
     plan: {
         id: string;
@@ -456,6 +1173,8 @@ interface ActiveSubscription {
 }
 interface CreatedSubscription {
     id: string;
+    object: "subscription";
+    livemode: boolean;
     customerId: string;
     planId: string;
     planName: string;
@@ -477,6 +1196,8 @@ interface CreatedSubscription {
 }
 interface Subscription {
     id: string;
+    object: "subscription";
+    livemode: boolean;
     customerId: string;
     planId: string;
     planName: string;
@@ -511,75 +1232,213 @@ type CreateSubscriptionParams = PlanIdentifier & {
     startDate?: string;
     successUrl?: string;
 };
+interface GetActiveParams {
+    customerId: string;
+}
 interface CancelParams {
-    subscriptionId: string;
+    id: string;
     reason?: string;
     immediate?: boolean;
 }
 interface UncancelParams {
-    subscriptionId: string;
+    id: string;
 }
-/**
- * Subscription resource for managing subscriptions (plan-first model)
- *
- * Each customer can only have ONE active subscription at a time.
- */
+interface ChangePlanParams {
+    id: string;
+    newPlanId?: string;
+    newBillingInterval?: BillingInterval;
+}
+interface ChangePlanResult {
+    id: string;
+    scheduled: boolean;
+    customerId?: string;
+    previousPlan?: {
+        id: string;
+        name: string;
+    };
+    currentPlan?: {
+        id: string;
+        name: string;
+        price: number;
+    };
+    billingInterval?: string;
+    billing?: {
+        credit: number;
+        creditsApplied: number;
+        charge: number;
+        taxAmount: number;
+        netAmount: number;
+        totalCharged: number;
+        remainingCreditBalance: number;
+    };
+    invoiceId?: string;
+    scheduledFor?: string;
+    changeType?: string;
+    requiresCheckout?: boolean;
+    checkoutUrl?: string;
+}
+interface ListSubscriptionsParams extends Record<string, unknown> {
+    customerId?: string;
+    status?: SubscriptionStatus;
+    limit?: number;
+    cursor?: string;
+}
+interface SubscriptionListItem {
+    id: string;
+    object: "subscription";
+    livemode: boolean;
+    customerId: string;
+    planId: string;
+    planName: string;
+    name: string;
+    status: SubscriptionStatus;
+    startDate: string;
+    endDate: string;
+    billingDayOfMonth: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PreviewChangeParams {
+    id: string;
+    planId?: string;
+    billingInterval?: BillingInterval;
+}
+interface PreviewChangeResult {
+    currentPlanCredit: number;
+    newPlanCharge: number;
+    estimatedTotal: number;
+    effectiveDate: string;
+    daysRemaining: number;
+    totalDays: number;
+    isUpgrade: boolean;
+}
+interface ActivateAddonParams {
+    id: string;
+    addonId: string;
+}
+interface ActivateAddonResult {
+    addonId: string;
+    status: string;
+    proratedCharge: number;
+}
+interface DeactivateAddonParams {
+    id: string;
+    addonId: string;
+}
+interface DeactivateAddonResult {
+    id: string;
+    status: string;
+    deactivatedAt: string;
+}
+interface AdjustBalanceParams {
+    id: string;
+    amount: number;
+    reason?: string;
+    type?: "balance" | "credits";
+}
+interface AdjustBalanceResult {
+    amount: number;
+    newBalance: number;
+    reason: string | null;
+}
+interface TopupBalanceParams {
+    id: string;
+    amount: number;
+}
+interface TopupBalanceResult {
+    amount: number;
+}
+interface PurchaseCreditsParams {
+    id: string;
+    creditPackId: string;
+}
+interface PurchaseCreditsResult {
+    credits: number;
+}
+/** Each customer can only have one active subscription at a time. */
 declare class SubscriptionsResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    /**
-     * Create a subscription with a plan
-     *
-     * @example
-     * ```typescript
-     * await commet.subscriptions.create({
-     *   externalId: 'user_123',
-     *   planCode: 'pro', // autocomplete works after `commet pull`
-     *   billingInterval: 'yearly',
-     *   initialSeats: { editor: 5 }
-     * });
-     * ```
-     */
+    /** Returns a `checkoutUrl` when payment is required before activation. */
     create(params: CreateSubscriptionParams, options?: RequestOptions): Promise<ApiResponse<CreatedSubscription>>;
-    /**
-     * Get the active subscription for a customer
-     *
-     * @example
-     * ```typescript
-     * const sub = await commet.subscriptions.get('user_123');
-     * ```
-     */
-    get(customerId: string): Promise<ApiResponse<ActiveSubscription | null>>;
-    /**
-     * Cancel a subscription
-     *
-     * @example
-     * ```typescript
-     * await commet.subscriptions.cancel({
-     *   subscriptionId: 'sub_xxx',
-     *   reason: 'switched_to_competitor'
-     * });
-     * ```
-     */
+    getActive(params: GetActiveParams): Promise<ApiResponse<ActiveSubscription | null>>;
+    /** Schedules cancellation at period end by default. Set `immediate: true` to cancel now. */
     cancel(params: CancelParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
-    /**
-     * Revert a scheduled cancellation
-     *
-     * Only works on subscriptions with a pending cancellation (canceledAt is set
-     * but status is not yet "canceled"). Cannot revert already-canceled subscriptions.
-     *
-     * @example
-     * ```typescript
-     * await commet.subscriptions.uncancel({
-     *   subscriptionId: 'sub_xxx',
-     * });
-     * ```
-     */
+    /** Only works on subscriptions with a pending cancellation — cannot revert already-canceled. */
     uncancel(params: UncancelParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
+    /** Upgrades execute immediately with proration. Downgrades are scheduled for end of period. */
+    changePlan(params: ChangePlanParams, options?: RequestOptions): Promise<ApiResponse<ChangePlanResult>>;
+    list(params?: ListSubscriptionsParams): Promise<ApiResponse<SubscriptionListItem[]>>;
+    /** Dry-run: returns proration details without applying the change. */
+    previewChange(params: PreviewChangeParams, options?: RequestOptions): Promise<ApiResponse<PreviewChangeResult>>;
+    /** Prorated charge for the current billing period. */
+    activateAddon(params: ActivateAddonParams, options?: RequestOptions): Promise<ApiResponse<ActivateAddonResult>>;
+    deactivateAddon(params: DeactivateAddonParams, options?: RequestOptions): Promise<ApiResponse<DeactivateAddonResult>>;
+    /** Positive amount adds, negative subtracts. */
+    adjustBalance(params: AdjustBalanceParams, options?: RequestOptions): Promise<ApiResponse<AdjustBalanceResult>>;
+    /** Charges the customer's payment method. */
+    topupBalance(params: TopupBalanceParams, options?: RequestOptions): Promise<ApiResponse<TopupBalanceResult>>;
+    purchaseCredits(params: PurchaseCreditsParams, options?: RequestOptions): Promise<ApiResponse<PurchaseCreditsResult>>;
+}
+
+interface TransactionListItem {
+    id: string;
+    object: "transaction";
+    livemode: boolean;
+    invoiceId: string;
+    grossAmount: number;
+    subtotal: number;
+    taxAmount: number;
+    currency: string;
+    status: string;
+    customerEmail: string;
+    customerName: string | null;
+    paidAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface TransactionDetail extends TransactionListItem {
+    availableAt: string | null;
+}
+interface TransactionRefundResult {
+    id: string;
+    status: string;
+}
+interface TransactionRetryResult {
+    id: string;
+    status: string;
+    retryInvoiceNumber: string;
+}
+interface ListTransactionsParams {
+    status?: string;
+    customerEmail?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface GetTransactionParams {
+    id: string;
+}
+interface RefundTransactionParams {
+    id: string;
+}
+interface RetryTransactionParams {
+    id: string;
+}
+declare class TransactionsResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    list(params?: ListTransactionsParams): Promise<ApiResponse<TransactionListItem[]>>;
+    get(params: GetTransactionParams): Promise<ApiResponse<TransactionDetail>>;
+    /** Full refund only. */
+    refund(params: RefundTransactionParams, options?: RequestOptions): Promise<ApiResponse<TransactionRefundResult>>;
+    /** Creates a new invoice and initiates a new payment attempt. */
+    retry(params: RetryTransactionParams, options?: RequestOptions): Promise<ApiResponse<TransactionRetryResult>>;
 }
 
 interface UsageEvent {
     id: EventID;
+    object: "usage_event";
+    livemode: boolean;
     organizationId: string;
     customerId: CustomerID;
     feature: string;
@@ -615,162 +1474,42 @@ interface TrackModelTokensParams extends TrackBaseParams {
     value?: never;
 }
 type TrackParams = TrackUsageParams | TrackModelTokensParams;
-declare class UsageResource {
-    private httpClient;
-    constructor(httpClient: CommetHTTPClient);
-    track(params: TrackParams, options?: RequestOptions): Promise<ApiResponse<UsageEvent>>;
-}
-
-declare class CustomerContext<TConfig = unknown> {
-    private readonly customerId;
-    private readonly featuresResource;
-    private readonly seatsResource;
-    private readonly usageResource;
-    private readonly subscriptionsResource;
-    private readonly portalResource;
-    constructor(customerId: string, resources: {
-        features: FeaturesResource;
-        seats: SeatsResource;
-        usage: UsageResource;
-        subscriptions: SubscriptionsResource;
-        portal: PortalResource;
-    });
-    features: {
-        get: (code: ResolvedFeatureCode<TConfig>, options?: RequestOptions) => Promise<ApiResponse<FeatureAccess>>;
-        check: (code: ResolvedFeatureCode<TConfig>, options?: RequestOptions) => Promise<ApiResponse<CheckResult>>;
-        canUse: (code: ResolvedFeatureCode<TConfig>, options?: RequestOptions) => Promise<ApiResponse<CanUseResult>>;
-        list: (options?: RequestOptions) => Promise<ApiResponse<FeatureAccess[]>>;
-    };
-    seats: {
-        add: (featureCode: ResolvedSeatCode<TConfig>, count?: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
-        remove: (featureCode: ResolvedSeatCode<TConfig>, count?: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
-        set: (featureCode: ResolvedSeatCode<TConfig>, count: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
-        getBalance: (featureCode: ResolvedSeatCode<TConfig>) => Promise<ApiResponse<SeatBalance>>;
-    };
-    usage: {
-        track: (feature: ResolvedUsageCode<TConfig>, value?: number, properties?: Record<string, string>, options?: RequestOptions) => Promise<ApiResponse<UsageEvent>>;
-    };
-    subscription: {
-        get: () => Promise<ApiResponse<ActiveSubscription | null>>;
-    };
-    portal: {
-        getUrl: (options?: RequestOptions) => Promise<ApiResponse<PortalAccess>>;
-    };
-}
-
-interface CreditPack {
-    id: string;
-    name: string;
-    description: string | null;
-    credits: number;
-    price: number;
-    currency: string;
-}
-/**
- * Credit Packs resource for listing available credit packs
- */
-declare class CreditPacksResource {
-    private httpClient;
-    constructor(httpClient: CommetHTTPClient);
-    /**
-     * List all active credit packs
-     *
-     * @example
-     * ```typescript
-     * const packs = await commet.creditPacks.list();
-     * console.log(packs.data); // [{ id: "cp_xxx", name: "100 Credits", ... }]
-     * ```
-     */
-    list(): Promise<ApiResponse<CreditPack[]>>;
-}
-
-interface Customer {
-    id: CustomerID;
-    organizationId: string;
-    externalId?: string;
-    fullName?: string;
-    domain?: string;
-    website?: string;
-    billingEmail: string;
-    timezone?: string;
-    language?: string;
-    industry?: string;
-    employeeCount?: string;
-    metadata?: Record<string, unknown>;
-    createdAt: string;
-    updatedAt: string;
-}
-interface CustomerAddress {
-    line1: string;
-    line2?: string;
-    city: string;
-    state?: string;
-    postalCode: string;
-    country: string;
-}
-interface CreateParams {
-    email: string;
-    id?: string;
-    fullName?: string;
-    domain?: string;
-    website?: string;
-    timezone?: string;
-    language?: string;
-    industry?: string;
-    metadata?: Record<string, unknown>;
-    address?: CustomerAddress;
-}
-interface UpdateParams {
+interface CheckUsageParams {
     customerId: CustomerID;
-    email?: string;
-    fullName?: string;
-    domain?: string;
-    website?: string;
-    timezone?: string;
-    language?: string;
-    industry?: string;
-    metadata?: Record<string, unknown>;
-    address?: CustomerAddress;
-}
-interface ListCustomersParams extends ListParams {
-    search?: string;
+    featureCode: string;
+    quantity: number;
 }
-interface BatchResult {
-    successful: Customer[];
-    failed: Array<{
-        index: number;
-        error: string;
-        data: CreateParams;
-    }>;
+interface UsageCheckResult {
+    allowed: boolean;
+    consumptionModel: string;
+    feature: string;
+    quantity: number;
+    current?: number;
+    remaining?: number;
+    unlimited?: boolean;
+    included?: number;
+    overageEnabled?: boolean;
+    overageUnitPrice?: number | null;
+    creditsPerUnit?: number;
+    estimatedCredits?: number;
+    planCredits?: number;
+    purchasedCredits?: number;
+    totalCredits?: number;
+    unitPrice?: number;
+    estimatedAmount?: number;
+    currentBalance?: number;
+    blockOnExhaustion?: boolean;
+    currency?: string;
+    reason?: string;
+    message?: string;
 }
-/**
- * Customers resource - Manage your customers
- */
-declare class CustomersResource {
+declare class UsageResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    /**
-     * Create a customer (idempotent when id is provided)
-     */
-    create(params: CreateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
-    /**
-     * Create multiple customers in batch
-     */
-    createBatch(params: {
-        customers: CreateParams[];
-    }, options?: RequestOptions): Promise<ApiResponse<BatchResult>>;
-    /**
-     * Get a customer by ID
-     */
-    get(customerId: CustomerID): Promise<ApiResponse<Customer>>;
-    /**
-     * Update a customer
-     */
-    update(params: UpdateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
-    /**
-     * List customers with optional filters
-     */
-    list(params?: ListCustomersParams): Promise<ApiResponse<Customer[]>>;
+    /** Deducts from balance/credits if the plan uses consumption. Duplicate `idempotencyKey` is rejected. */
+    track(params: TrackParams, options?: RequestOptions): Promise<ApiResponse<UsageEvent>>;
+    /** Dry-run: checks if a usage event would be allowed without actually tracking it. */
+    check(params: CheckUsageParams, options?: RequestOptions): Promise<ApiResponse<UsageCheckResult>>;
 }
 
 /**
@@ -795,7 +1534,6 @@ interface WebhookData {
     publicId?: string;
     subscriptionId?: string;
     customerId?: string;
-    externalId?: string;
     /**
      * Subscription status. Present on `subscription.*` events.
      * Grant access when this is `"active"` or `"trialing"`.
@@ -819,112 +1557,80 @@ interface VerifyAndParseParams {
     signature: string | null;
     secret: string;
 }
-/**
- * Webhooks resource for signature verification
- */
+interface WebhookEndpoint {
+    id: string;
+    object: "webhook_endpoint";
+    livemode: boolean;
+    url: string;
+    events: string[];
+    description: string | null;
+    isActive: boolean;
+    createdAt: string;
+}
+interface WebhookEndpointCreated extends WebhookEndpoint {
+    secretKey: string;
+}
+interface WebhookTestResult {
+    success: boolean;
+    deliveredAt: string;
+}
+interface ListWebhooksParams {
+    limit?: number;
+    cursor?: string;
+}
+interface CreateWebhookParams {
+    url: string;
+    events: string[];
+    description?: string;
+}
+interface DeleteWebhookParams {
+    id: string;
+}
+interface TestWebhookParams {
+    id: string;
+}
 declare class Webhooks {
-    /**
-     * Verify HMAC-SHA256 webhook signature
-     *
-     * Use this method to verify that webhooks are authentically from Commet.
-     * The signature is included in the `X-Commet-Signature` header.
-     *
-     * @param payload - Raw request body as string (IMPORTANT: Do not parse JSON first)
-     * @param signature - Value from X-Commet-Signature header
-     * @param secret - Your webhook secret from Commet dashboard
-     * @returns true if signature is valid, false otherwise
-     *
-     * @example
-     * ```typescript
-     * // Next.js API route example
-     * export async function POST(request: Request) {
-     *   const rawBody = await request.text();
-     *   const signature = request.headers.get('x-commet-signature');
-     *
-     *   const isValid = commet.webhooks.verify(
-     *     rawBody,
-     *     signature,
-     *     process.env.COMMET_WEBHOOK_SECRET
-     *   );
-     *
-     *   if (!isValid) {
-     *     return new Response('Invalid signature', { status: 401 });
-     *   }
-     *
-     *   const payload = JSON.parse(rawBody);
-     *   // Handle webhook event...
-     * }
-     * ```
-     */
+    private httpClient?;
+    constructor(httpClient?: CommetHTTPClient | undefined);
+    /** HMAC-SHA256 verification. Payload must be the raw request body string, not parsed JSON. */
     verify(params: VerifyParams): boolean;
-    /**
-     * Generate HMAC-SHA256 signature (internal use)
-     * @internal
-     */
     private generateSignature;
-    /**
-     * Parse and verify webhook payload in one step
-     *
-     * @example
-     * ```typescript
-     * const payload = commet.webhooks.verifyAndParse({
-     *   rawBody,
-     *   signature,
-     *   secret: process.env.COMMET_WEBHOOK_SECRET
-     * });
-     *
-     * if (!payload) {
-     *   return new Response('Invalid signature', { status: 401 });
-     * }
-     *
-     * // payload is typed and validated
-     * if (payload.event === 'subscription.activated') {
-     *   // Handle activation...
-     * }
-     * ```
-     */
+    /** Verifies signature and parses JSON in one step. Returns null if invalid. */
     verifyAndParse(params: VerifyAndParseParams): WebhookPayload | null;
+    list(params?: ListWebhooksParams, options?: RequestOptions): Promise<ApiResponse<WebhookEndpoint[]>>;
+    /** Response includes `secretKey` which is only returned once. */
+    create(params: CreateWebhookParams, options?: RequestOptions): Promise<ApiResponse<WebhookEndpointCreated>>;
+    delete(params: DeleteWebhookParams, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        deleted: true;
+    }>>;
+    test(params: TestWebhookParams, options?: RequestOptions): Promise<ApiResponse<WebhookTestResult>>;
 }
 
-/**
- * Main Commet SDK client
- */
-declare class Commet<TConfig = unknown> {
+declare class Commet<_TConfig = unknown> {
     private httpClient;
-    readonly customers: CustomersResource;
+    readonly addons: AddonsResource;
+    readonly apiKeys: ApiKeysResource;
     readonly creditPacks: CreditPacksResource;
+    readonly customers: CustomersResource;
+    readonly features: FeaturesResource;
+    readonly invoices: InvoicesResource;
+    readonly planGroups: PlanGroupsResource;
     readonly plans: PlansResource;
-    readonly usage: UsageResource;
+    readonly portal: PortalResource;
+    readonly promoCodes: PromoCodesResource;
     readonly seats: SeatsResource;
     readonly subscriptions: SubscriptionsResource;
-    readonly portal: PortalResource;
-    readonly features: FeaturesResource;
+    readonly transactions: TransactionsResource;
+    readonly usage: UsageResource;
     readonly webhooks: Webhooks;
     constructor(config: CommetClientOptions);
-    /**
-     * Create a customer-scoped context for cleaner API usage
-     *
-     * @example
-     * ```typescript
-     * const customer = commet.customer("user_123");
-     *
-     * // All operations are now scoped to this customer
-     * const seats = await customer.features.get("team_members");
-     * await customer.seats.add("member");
-     * await customer.usage.track("api_call");
-     * ```
-     */
-    customer(customerId: string): CustomerContext<TConfig>;
 }
 declare function createCommet<const TConfig extends BillingConfig>(_billingConfig: TConfig, options: CommetClientOptions): Commet<TConfig>;
 
 declare function registerIntegration(name: string, version: string): void;
 
-declare const API_VERSION = "2026-05-18";
+declare const API_VERSION = "2026-05-25";
 declare const SDK_VERSION: string;
 
-/**
- * Commet SDK - Billing and usage tracking for SaaS
- */
-
-export { API_VERSION, type ActiveSubscription, type AddParams as AddSeatsParams, type ApiResponse, type BillingConfig, type BillingInterval, type CanUseFeatureParams, type CanUseResult, type CancelParams, type CancellationSummary, type CheckFeatureParams, type CheckResult, Commet, CommetAPIError, type CommetClientOptions, type CommetConfig, CommetError, CommetValidationError, type CreateParams as CreateCustomerParams, type CreateSubscriptionParams, type CreatedSubscription, type CreditPack, type Currency, type Customer, type CustomerAddress, CustomerContext, type CustomerID, type BatchResult as CustomersBatchResult, type DiscountSummary, type EventID, type FeatureAccess, type FeatureDef, type FeatureSummary, type FeatureType, type GetAllBalancesParams, type GetBalanceParams, type GetFeatureParams, type GetUrlParams, type InferFeatureCodes, type InferPlanCodes, type InferSeatCodes, type InferUsageCodes, type ListCustomersParams, type ListPlansParams, type PaginatedList, type PaginatedResponse, type Plan, type PlanDef, type PlanDetail, type PlanFeature, type PlanFeatureValue, type PlanID, type PlanPrice, type PortalAccess, type PriceDef, type RemoveParams as RemoveSeatsParams, type RequestOptions, type ResolvedFeatureCode, type ResolvedPlanCode, type ResolvedSeatCode, type ResolvedUsageCode, SDK_VERSION, type SeatBalance, type SeatEvent, type SetAllParams as SetAllSeatsParams, type SetParams as SetSeatsParams, type Subscription, type SubscriptionStatus, type TrackModelTokensParams, type TrackParams, type TrackUsageParams, type UpdateParams as UpdateCustomerParams, type UsageEvent, type UsageEventProperty, type WebhookData, type WebhookEvent, type WebhookPayload, Webhooks, createCommet, Commet as default, defineConfig, registerIntegration };
+export { API_VERSION, type ActivateAddonParams, type ActivateAddonResult, type ActiveAddon, type ActiveSubscription, type AddAiModelPricingFeatureParams, type AddFixedPricingFeatureParams, type AddPlanFeatureParams, type AddPlanPriceParams, type AddPlanToGroupParams, type AddSeatsParams, type Addon, type AdjustBalanceParams, type AdjustBalanceResult, type AiModelPricingFeatureManage, type ApiErrorDetail, type ApiKey, type ApiKeyCreated, type ApiResponse, type BalanceAddon, type BillingConfig, type BillingInterval, type BooleanAddon, type CanUseFeatureParams, type CanUseResult, type CancelParams, type CancellationSummary, type ChangePlanParams, type ChangePlanResult, type CheckUsageParams, Commet, CommetAPIError, type CommetClientOptions, CommetError, CommetValidationError, type CreateAddonParams, type CreateAdjustmentParams, type CreateAdjustmentResult, type CreateApiKeyParams, type CreateBalanceAddonParams, type CreateBooleanAddonParams, type CreateCreditPackParams, type CreateCreditsAddonParams, type CreateParams as CreateCustomerParams, type CreateFeatureParams, type CreateMeteredAddonParams, type CreatePlanGroupParams, type CreatePlanParams, type CreatePromoCodeParams, type CreateSubscriptionParams, type CreateWebhookParams, type CreatedSubscription, type CreditPack, type CreditPackDetail, type CreditsAddon, type Currency, type Customer, type CustomerAddress, type CustomerID, type BatchResult as CustomersBatchResult, type DeactivateAddonParams, type DeactivateAddonResult, type DeleteAddonParams, type DeleteApiKeyParams, type DeleteCreditPackParams, type DeleteFeatureParams, type DeletePlanGroupParams, type DeletePlanParams, type DeletePlanPriceParams, type DeleteRegionalPricesParams, type DeleteResult, type DeleteWebhookParams, type DiscountSummary, type EventID, type Feature, type FeatureAccess, type FeatureDef, type FeatureSummary, type FeatureType, type FixedPricingFeatureManage, type GetActiveParams, type GetAddonParams, type GetAllBalancesParams, type GetBalanceParams, type GetCustomerParams, type GetDownloadUrlParams, type GetFeatureParams, type GetInvoiceParams, type GetPlanGroupParams, type GetPromoCodeParams, type GetTransactionParams, type GetUrlParams, type InferFeatureCodes, type InferPlanCodes, type InferSeatCodes, type InferUsageCodes, type InvoiceDetail, type InvoiceDownloadResult, type InvoiceLineItem, type InvoiceListItem, type InvoiceSendResult, type InvoiceStatusResult, type ListActiveAddonsParams, type ListAddonsParams, type ListApiKeysParams, type ListCustomersParams, type ListFeaturesParams, type ListInvoicesParams, type ListPlanGroupsParams, type ListPlansParams, type ListPromoCodesParams, type ListSubscriptionsParams, type ListTransactionsParams, type ListWebhooksParams, type MeteredAddon, type PaginatedList, type PaginatedResponse, type Plan, type PlanDef, type PlanDetail, type PlanFeature, type PlanFeatureManage, type PlanFeatureValue, type PlanGroup, type PlanGroupDetail, type PlanID, type PlanManage, type PlanPrice, type PlanPriceManage, type PortalAccess, type PreviewChangeParams, type PreviewChangeResult, type PriceDef, type PromoCode, type PromoCodeDetail, type PurchaseCreditsParams, type PurchaseCreditsResult, type RefundTransactionParams, type RegionalPriceResult, type RemovePlanFeatureParams, type RemovePlanFromGroupParams, type RemoveResult, type RemoveSeatsParams, type ReorderPlansParams, type RequestOptions, type ResolvedFeatureCode, type ResolvedPlanCode, type ResolvedSeatCode, type ResolvedUsageCode, type RetryTransactionParams, SDK_VERSION, type SeatBalance, type SeatEvent, type SendInvoiceParams, type SetAllSeatsParams, type SetDefaultPriceParams, type SetRegionalPricesParams, type SetSeatsParams, type SetVisibilityParams, type Subscription, type SubscriptionListItem, type SubscriptionStatus, type TestWebhookParams, type TopupBalanceParams, type TopupBalanceResult, type TrackModelTokensParams, type TrackParams, type TrackUsageParams, type TransactionDetail, type TransactionListItem, type TransactionRefundResult, type TransactionRetryResult, type UncancelParams, type UpdateAddonParams, type UpdateCreditPackParams, type UpdateParams as UpdateCustomerParams, type UpdateFeatureParams, type UpdateInvoiceStatusParams, type UpdatePlanFeatureParams, type UpdatePlanGroupParams, type UpdatePlanParams, type UpdatePlanPriceParams, type UpdatePromoCodeParams, type UsageCheckResult, type UsageEvent, type UsageEventProperty, type WebhookData, type WebhookEndpoint, type WebhookEndpointCreated, type WebhookEvent, type WebhookPayload, type WebhookTestResult, Webhooks, createCommet, Commet as default, defineConfig, registerIntegration };