@commet/node 0.11.0 → 1.0.0

package/dist/index.d.ts

@@ -41,13 +41,7 @@ declare class CommetValidationError extends CommetError {
     constructor(message: string, validationErrors: Record<string, string[]>);
 }
 type CustomerID = `cus_${string}`;
-type AgreementID = `agr_${string}`;
-type InvoiceID = `inv_${string}`;
-type PhaseID = `phs_${string}`;
-type ItemID = `itm_${string}`;
-type ProductID = `prd_${string}`;
 type EventID = `evt_${string}`;
-type WebhookID = `wh_${string}`;
 type Currency = "USD" | "EUR" | "GBP" | "CAD" | "AUD" | "JPY" | "ARS" | "BRL" | "MXN" | "CLP";
 interface ListParams extends Record<string, unknown> {
     limit?: number;
@@ -55,9 +49,6 @@ interface ListParams extends Record<string, unknown> {
     startDate?: string;
     endDate?: string;
 }
-interface RetrieveOptions {
-    expand?: string[];
-}
 interface RequestOptions {
     idempotencyKey?: string;
     timeout?: number;
@@ -93,8 +84,14 @@ type GeneratedSeatType = CommetGeneratedTypes extends {
 /**
  * Helper type that provides fallback to string if types are not generated
  */
-type GeneratedProductId = CommetGeneratedTypes extends {
-    productId: infer T;
+type GeneratedPlanCode = CommetGeneratedTypes extends {
+    planCode: infer T;
+} ? T : string;
+/**
+ * Helper type that provides fallback to string if types are not generated
+ */
+type GeneratedFeatureCode = CommetGeneratedTypes extends {
+    featureCode: infer T;
 } ? T : string;
 
 declare class CommetHTTPClient {
@@ -136,15 +133,11 @@ interface Customer {
     id: CustomerID;
     organizationId: string;
     externalId?: string;
-    legalName: string;
+    legalName?: string;
     displayName?: string;
     domain?: string;
     website?: string;
-    taxStatus: "TAXED" | "TAX_EXEMPT" | "REVERSE_CHARGE" | "NOT_APPLICABLE";
-    currency: Currency;
-    addressId: string;
-    billingEmail?: string;
-    paymentTerms?: string;
+    billingEmail: string;
     timezone?: string;
     language?: string;
     industry?: string;
@@ -154,21 +147,6 @@ interface Customer {
     createdAt: string;
     updatedAt: string;
 }
-interface CreateCustomerBaseParams {
-    externalId?: string;
-    legalName: string;
-    displayName?: string;
-    domain?: string;
-    website?: string;
-    currency?: Currency;
-    billingEmail?: string;
-    paymentTerms?: string;
-    timezone?: string;
-    language?: string;
-    industry?: string;
-    employeeCount?: string;
-    metadata?: Record<string, unknown>;
-}
 interface CustomerAddress {
     line1: string;
     line2?: string;
@@ -176,140 +154,199 @@ interface CustomerAddress {
     state?: string;
     postalCode: string;
     country: string;
-    region?: string;
 }
-interface CreateCustomerTaxed extends CreateCustomerBaseParams {
-    taxStatus: "TAXED";
-    address: CustomerAddress;
-}
-interface CreateCustomerOtherTaxStatus extends CreateCustomerBaseParams {
-    taxStatus?: "TAX_EXEMPT" | "REVERSE_CHARGE" | "NOT_APPLICABLE";
+interface CreateParams {
+    email: string;
+    externalId?: string;
+    legalName?: string;
+    displayName?: string;
+    domain?: string;
+    website?: string;
+    timezone?: string;
+    language?: string;
+    industry?: string;
+    metadata?: Record<string, unknown>;
     address?: CustomerAddress;
 }
-type CreateCustomerParams = CreateCustomerTaxed | CreateCustomerOtherTaxStatus;
-interface UpdateCustomerParams {
+interface UpdateParams {
     externalId?: string;
+    email?: string;
     legalName?: string;
     displayName?: string;
     domain?: string;
     website?: string;
-    taxStatus?: "TAXED" | "TAX_EXEMPT" | "REVERSE_CHARGE" | "NOT_APPLICABLE";
-    currency?: Currency;
-    billingEmail?: string;
-    paymentTerms?: string;
     timezone?: string;
     language?: string;
     industry?: string;
-    employeeCount?: string;
     metadata?: Record<string, unknown>;
-    isActive?: boolean;
 }
 interface ListCustomersParams extends ListParams {
     externalId?: string;
-    taxStatus?: "TAXED" | "TAX_EXEMPT" | "REVERSE_CHARGE" | "NOT_APPLICABLE";
-    currency?: Currency;
     isActive?: boolean;
     search?: string;
 }
+interface BatchResult$1 {
+    successful: Customer[];
+    failed: Array<{
+        index: number;
+        error: string;
+        data: CreateParams;
+    }>;
+}
 /**
- * Customer resource for managing customer data
+ * Customers resource - Manage your customers
  */
 declare class CustomersResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    create(params: CreateCustomerParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
-    retrieve(customerId: CustomerID, options?: RetrieveOptions): Promise<ApiResponse<Customer>>;
-    update(customerId: CustomerID, params: UpdateCustomerParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
+    /**
+     * Create a customer (idempotent with externalId)
+     */
+    create(params: CreateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
+    /**
+     * Create multiple customers in batch
+     */
+    createBatch(params: {
+        customers: CreateParams[];
+    }, options?: RequestOptions): Promise<ApiResponse<BatchResult$1>>;
+    /**
+     * Get a customer by ID
+     */
+    get(customerId: CustomerID): Promise<ApiResponse<Customer>>;
+    /**
+     * Update a customer
+     */
+    update(customerId: CustomerID, params: UpdateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
+    /**
+     * List customers with optional filters
+     */
     list(params?: ListCustomersParams): Promise<ApiResponse<Customer[]>>;
     /**
-     * Deactivate a customer (soft delete)
+     * Archive a customer
      */
-    deactivate(customerId: CustomerID, options?: RequestOptions): Promise<ApiResponse<Customer>>;
+    archive(customerId: CustomerID, options?: RequestOptions): Promise<ApiResponse<Customer>>;
 }
 
+type PlanID = `plan_${string}`;
+type BillingInterval = "monthly" | "quarterly" | "yearly";
+type FeatureType = "boolean" | "metered" | "seats";
+interface PlanPrice {
+    billingInterval: BillingInterval;
+    price: number;
+    isDefault: boolean;
+}
+interface PlanFeature {
+    code: string;
+    name: string;
+    type: FeatureType;
+    enabled?: boolean;
+    includedAmount?: number;
+    unlimited?: boolean;
+    overageEnabled?: boolean;
+    overageUnitPrice?: number;
+}
+interface Plan {
+    id: PlanID;
+    name: string;
+    description?: string;
+    isPublic: boolean;
+    isDefault: boolean;
+    trialDays: number;
+    sortOrder: number;
+    prices: PlanPrice[];
+    features: PlanFeature[];
+    createdAt: string;
+}
+interface PlanDetail extends Plan {
+    features: Array<PlanFeature & {
+        unitName?: string;
+        overage?: {
+            enabled: boolean;
+            model: "per_unit" | "tiered";
+            unitPrice: number;
+            tiers?: Array<{
+                order: number;
+                upTo: number | null;
+                unitAmount: number;
+                flatFee: number;
+            }>;
+        } | null;
+    }>;
+    updatedAt: string;
+}
+interface ListPlansParams extends ListParams {
+    includePrivate?: boolean;
+}
 /**
- * Portal access response
+ * Plans resource for listing available plans
  */
+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 ID
+     *
+     * @example
+     * ```typescript
+     * const plan = await commet.plans.get('plan_xxx');
+     * console.log(plan.data.name); // "Pro"
+     * console.log(plan.data.prices); // [{ billingInterval: 'monthly', price: 9900 }]
+     * ```
+     */
+    get(planId: string): Promise<ApiResponse<PlanDetail>>;
+}
+
 interface PortalAccess {
     success: boolean;
     message: string;
     portalUrl: string;
 }
-/**
- * Request portal access by customer ID
- */
-interface RequestAccessByCustomerId {
+interface GetUrlByCustomerId {
     customerId: CustomerID;
     email?: never;
     externalId?: never;
 }
-/**
- * Request portal access by external ID
- */
-interface RequestAccessByExternalId {
+interface GetUrlByExternalId {
     externalId: string;
     email?: never;
     customerId?: never;
 }
-/**
- * Request portal access by email
- */
-interface RequestAccessByEmail {
+interface GetUrlByEmail {
     email: string;
     customerId?: never;
     externalId?: never;
 }
+type GetUrlParams = GetUrlByCustomerId | GetUrlByExternalId | GetUrlByEmail;
 /**
- * Portal access parameters
- */
-type RequestAccessParams = RequestAccessByCustomerId | RequestAccessByExternalId | RequestAccessByEmail;
-/**
- * Customer Portal resource for generating customer portal access
+ * Portal resource - Generate customer portal access
  */
 declare class PortalResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
     /**
-     * Request portal access for a customer
-     *
-     * Generates a secure portal URL that can be sent to the customer via email or used directly.
-     * The URL contains a time-limited token for secure access to the customer portal.
-     *
-     * @param params - customerId, externalId, or email
-     * @param options - Request options (idempotency, timeout)
-     * @returns Portal access response with URL
+     * Get a portal URL
      *
      * @example
-     * // External ID (recommended)
-     * const portal = await commet.portal.requestAccess({
-     *   externalId: 'my-customer-123'
-     * });
-     *
-     * @example
-     * // Customer ID
-     * const portal = await commet.portal.requestAccess({
-     *   customerId: 'cus_123'
-     * });
-     *
-     * @example
-     * // Email
-     * const portal = await commet.portal.requestAccess({
-     *   email: 'customer@example.com'
-     * });
+     * ```typescript
+     * const portal = await commet.portal.getUrl({ externalId: 'user_123' });
+     * ```
      */
-    requestAccess(params: RequestAccessParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
+    getUrl(params: GetUrlParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
 }
 
-interface SeatBalance {
-    id: string;
-    organizationId: string;
-    customerId: CustomerID;
-    seatType: GeneratedSeatType;
-    balance: number;
-    asOf: string;
-    createdAt: string;
-    updatedAt: string;
-}
 interface SeatEvent {
     id: string;
     organizationId: string;
@@ -322,35 +359,32 @@ interface SeatEvent {
     ts: string;
     createdAt: string;
 }
-interface SeatBalanceResponse {
+interface SeatBalance {
     current: number;
     asOf: string;
 }
-interface BulkSeatUpdate {
-    [seatType: string]: number;
-}
-interface AddSeatsParams {
+interface AddParams {
     customerId?: CustomerID;
     externalId?: string;
     seatType: GeneratedSeatType;
     count: number;
 }
-interface RemoveSeatsParams {
+interface RemoveParams {
     customerId?: CustomerID;
     externalId?: string;
     seatType: GeneratedSeatType;
     count: number;
 }
-interface SetSeatsParams {
+interface SetParams {
     customerId?: CustomerID;
     externalId?: string;
     seatType: GeneratedSeatType;
     count: number;
 }
-interface BulkUpdateSeatsParams {
+interface SetAllParams {
     customerId?: CustomerID;
     externalId?: string;
-    seats: BulkSeatUpdate;
+    seats: Record<string, number>;
 }
 interface GetBalanceParams {
     customerId?: CustomerID;
@@ -361,45 +395,145 @@ interface GetAllBalancesParams {
     customerId?: CustomerID;
     externalId?: string;
 }
-interface ListSeatEventsParams extends ListParams {
-    customerId?: CustomerID;
-    externalId?: string;
-    seatType?: GeneratedSeatType;
-    eventType?: "add" | "remove" | "set";
-}
 /**
- * Seats resource for seat-based billing management
+ * Seats resource - Manage seat-based licenses
  */
 declare class SeatsResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    add(params: AddSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
-    remove(params: RemoveSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
-    set(params: SetSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
-    bulkUpdate(params: BulkUpdateSeatsParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent[]>>;
-    getBalance(params: GetBalanceParams): Promise<ApiResponse<SeatBalanceResponse>>;
-    getAllBalances(params: GetAllBalancesParams): Promise<ApiResponse<Record<string, SeatBalanceResponse>>>;
-    listEvents(params?: ListSeatEventsParams): Promise<ApiResponse<SeatEvent[]>>;
+    /**
+     * Add seats
+     *
+     * @example
+     * ```typescript
+     * await commet.seats.add({
+     *   externalId: 'user_123',
+     *   seatType: 'editor',
+     *   count: 5
+     * });
+     * ```
+     */
+    add(params: AddParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
+    /**
+     * Remove seats
+     *
+     * @example
+     * ```typescript
+     * await commet.seats.remove({
+     *   externalId: 'user_123',
+     *   seatType: 'editor',
+     *   count: 2
+     * });
+     * ```
+     */
+    remove(params: RemoveParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
+    /**
+     * Set seats to a specific count
+     *
+     * @example
+     * ```typescript
+     * await commet.seats.set({
+     *   externalId: 'user_123',
+     *   seatType: 'editor',
+     *   count: 10
+     * });
+     * ```
+     */
+    set(params: SetParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
+    /**
+     * Set all seat types
+     *
+     * @example
+     * ```typescript
+     * await commet.seats.setAll({
+     *   externalId: 'user_123',
+     *   seats: { editor: 10, viewer: 50 }
+     * });
+     * ```
+     */
+    setAll(params: SetAllParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent[]>>;
+    /**
+     * Get balance for a seat type
+     *
+     * @example
+     * ```typescript
+     * const balance = await commet.seats.getBalance({
+     *   externalId: 'user_123',
+     *   seatType: 'editor'
+     * });
+     * ```
+     */
+    getBalance(params: GetBalanceParams): Promise<ApiResponse<SeatBalance>>;
+    /**
+     * Get all seat balances
+     *
+     * @example
+     * ```typescript
+     * const balances = await commet.seats.getAllBalances({
+     *   externalId: 'user_123'
+     * });
+     * ```
+     */
+    getAllBalances(params: GetAllBalancesParams): Promise<ApiResponse<Record<string, SeatBalance>>>;
 }
 
-interface Subscription {
+type SubscriptionStatus = "draft" | "pending_payment" | "trialing" | "active" | "paused" | "past_due" | "canceled" | "expired";
+interface FeatureSummary {
+    code: string;
+    name: string;
+    type: "boolean" | "metered" | "seats";
+    enabled?: boolean;
+    usage?: {
+        current: number;
+        included: number;
+        overage: number;
+    };
+}
+interface ActiveSubscription {
     id: string;
     customerId: string;
+    plan: {
+        id: string;
+        name: string;
+        basePrice: number;
+        billingInterval: BillingInterval;
+    };
     name: string;
     description?: string;
-    status: "draft" | "pending_payment" | "active" | "completed" | "canceled";
+    status: SubscriptionStatus;
+    trialEndsAt?: string;
+    currentPeriod: {
+        start: string;
+        end: string;
+        daysRemaining: number;
+    };
+    features: FeatureSummary[];
     startDate: string;
     endDate?: string;
     billingDayOfMonth: number;
-    isTemplate?: boolean;
+    nextBillingDate: string;
     checkoutUrl?: string;
     createdAt: string;
     updatedAt: string;
 }
-interface SubscriptionItem {
-    priceId: string;
-    quantity?: number;
-    initialSeats?: number;
+interface Subscription {
+    id: string;
+    customerId: string;
+    planId: string;
+    planName: string;
+    name: string;
+    description?: string;
+    status: SubscriptionStatus;
+    billingInterval: BillingInterval;
+    trialEndsAt?: string;
+    startDate: string;
+    endDate?: string;
+    currentPeriodStart?: string;
+    currentPeriodEnd?: string;
+    billingDayOfMonth: number;
+    checkoutUrl?: string;
+    createdAt: string;
+    updatedAt: string;
 }
 type CustomerIdentifier = {
     customerId: string;
@@ -408,82 +542,81 @@ type CustomerIdentifier = {
     customerId?: never;
     externalId: string;
 };
-type CreateSubscriptionParams = CustomerIdentifier & {
-    items: SubscriptionItem[];
+type PlanIdentifier = {
+    planCode: GeneratedPlanCode;
+    planId?: never;
+} | {
+    planCode?: never;
+    planId: string;
+};
+type CreateSubscriptionParams = CustomerIdentifier & PlanIdentifier & {
+    billingInterval?: BillingInterval;
+    initialSeats?: Record<string, number>;
+    skipTrial?: boolean;
     name?: string;
     startDate?: string;
-    status?: "draft" | "pending_payment" | "active";
 };
-interface ListSubscriptionsParams extends ListParams {
-    customerId?: string;
-    externalId?: string;
-    status?: "draft" | "pending_payment" | "active" | "completed" | "canceled";
+type ChangePlanParams = PlanIdentifier & {
+    billingInterval?: BillingInterval;
+};
+interface CancelParams {
+    reason?: string;
+    immediate?: boolean;
 }
+type GetSubscriptionParams = CustomerIdentifier;
 /**
- * Subscription resource for managing subscriptions
+ * Subscription resource for managing subscriptions (plan-first model)
+ *
+ * Each customer can only have ONE active subscription at a time.
  */
 declare class SubscriptionsResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
     /**
-     * Create a subscription with multiple items (products)
+     * Create a subscription with a plan
      *
      * @example
      * ```typescript
-     * // Free plan - Multiple products
-     * await commet.subscriptions.create({
-     *   externalId: "org_123",
-     *   items: [
-     *     { priceId: "price_tasks_free", quantity: 1 },
-     *     { priceId: "price_usage_free" },
-     *     { priceId: "price_seats_free", initialSeats: 1 }
-     *   ]
-     * });
-     *
-     * // Pro plan upgrade
      * await commet.subscriptions.create({
-     *   customerId: "cus_xxx",
-     *   items: [
-     *     { priceId: "price_tasks_pro" },
-     *     { priceId: "price_usage_pro" },
-     *     { priceId: "price_seats_pro", initialSeats: 5 }
-     *   ],
-     *   status: "active"
+     *   externalId: 'user_123',
+     *   planCode: 'pro', // autocomplete works after `commet pull`
+     *   billingInterval: 'yearly',
+     *   initialSeats: { editor: 5 }
      * });
      * ```
      */
     create(params: CreateSubscriptionParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
     /**
-     * Retrieve a subscription by ID
+     * Get the active subscription for a customer
+     *
+     * @example
+     * ```typescript
+     * const sub = await commet.subscriptions.get({ externalId: 'user_123' });
+     * ```
      */
-    retrieve(subscriptionId: string, options?: RetrieveOptions): Promise<ApiResponse<Subscription>>;
+    get(params: GetSubscriptionParams): Promise<ApiResponse<ActiveSubscription | null>>;
     /**
-     * List subscriptions with optional filters
+     * Change the plan of a subscription (upgrade/downgrade)
      *
      * @example
      * ```typescript
-     * // List all active subscriptions for a customer
-     * await commet.subscriptions.list({
-     *   customerId: "cus_xxx",
-     *   status: "active"
-     * });
-     *
-     * // Using externalId
-     * await commet.subscriptions.list({
-     *   externalId: "my-customer-123"
+     * await commet.subscriptions.changePlan('sub_xxx', {
+     *   planCode: 'enterprise' // autocomplete works after `commet pull`
      * });
      * ```
      */
-    list(params?: ListSubscriptionsParams): Promise<ApiResponse<Subscription[]>>;
+    changePlan(subscriptionId: string, params: ChangePlanParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
     /**
      * Cancel a subscription
      *
      * @example
      * ```typescript
-     * await commet.subscriptions.cancel("sub_xxx");
+     * await commet.subscriptions.cancel('sub_xxx', {
+     *   reason: 'switched_to_competitor'
+     * });
      * ```
      */
-    cancel(subscriptionId: string, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
+    cancel(subscriptionId: string, params?: CancelParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
 }
 
 interface UsageEvent {
@@ -503,47 +636,59 @@ interface UsageEventProperty {
     value: string;
     createdAt: string;
 }
-interface CreateUsageEventParams {
-    eventType: GeneratedEventType;
-    customerId?: CustomerID;
-    externalId?: string;
-    idempotencyKey?: string;
-    timestamp?: string;
-    properties?: Array<{
-        property: string;
-        value: string;
-    }>;
-}
-interface CreateBatchUsageEventsParams {
-    events: CreateUsageEventParams[];
-}
 interface BatchResult<T> {
     successful: T[];
     failed: Array<{
         index: number;
         error: string;
-        data: CreateUsageEventParams;
+        data: TrackParams;
     }>;
 }
-interface ListUsageEventsParams extends ListParams {
+interface TrackParams {
+    eventType: GeneratedEventType;
     customerId?: CustomerID;
     externalId?: string;
-    eventType?: GeneratedEventType;
     idempotencyKey?: string;
+    value?: number;
+    timestamp?: string;
+    properties?: Record<string, string>;
 }
 /**
- * Usage Events resource - Track business events for usage-based billing
+ * Usage resource - Track consumption events for usage-based billing
  */
 declare class UsageResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
-    create(params: CreateUsageEventParams, options?: RequestOptions): Promise<ApiResponse<UsageEvent>>;
-    createBatch(params: CreateBatchUsageEventsParams, options?: RequestOptions): Promise<ApiResponse<BatchResult<UsageEvent>>>;
-    retrieve(eventId: EventID): Promise<ApiResponse<UsageEvent>>;
-    list(params?: ListUsageEventsParams): Promise<ApiResponse<UsageEvent[]>>;
-    delete(eventId: EventID, options?: RequestOptions): Promise<ApiResponse<{
-        deleted: boolean;
-    }>>;
+    /**
+     * Track a usage event
+     *
+     * @example
+     * ```typescript
+     * await commet.usage.track({
+     *   externalId: 'user_123',
+     *   eventType: 'api_call',
+     *   idempotencyKey: `evt_${requestId}`,
+     *   properties: { endpoint: '/users', method: 'GET' }
+     * });
+     * ```
+     */
+    track(params: TrackParams, options?: RequestOptions): Promise<ApiResponse<UsageEvent>>;
+    /**
+     * Track multiple usage events in a batch
+     *
+     * @example
+     * ```typescript
+     * await commet.usage.trackBatch({
+     *   events: [
+     *     { externalId: 'user_123', eventType: 'api_call', idempotencyKey: 'evt_1' },
+     *     { externalId: 'user_456', eventType: 'api_call', idempotencyKey: 'evt_2' }
+     *   ]
+     * });
+     * ```
+     */
+    trackBatch(params: {
+        events: TrackParams[];
+    }, options?: RequestOptions): Promise<ApiResponse<BatchResult<UsageEvent>>>;
 }
 
 /**
@@ -652,6 +797,7 @@ declare class Commet {
     private httpClient;
     private environment;
     readonly customers: CustomersResource;
+    readonly plans: PlansResource;
     readonly usage: UsageResource;
     readonly seats: SeatsResource;
     readonly subscriptions: SubscriptionsResource;
@@ -673,7 +819,7 @@ declare function isSandbox(environment: Environment): boolean;
 declare function isProduction(environment: Environment): boolean;
 
 /**
- * Commet SDK - Billing and usage tracking SDK
+ * Commet SDK - Billing and usage tracking for SaaS
  */
 
-export { type AddSeatsParams, type AgreementID, type ApiResponse, type BatchResult, type BulkSeatUpdate, type BulkUpdateSeatsParams, Commet, CommetAPIError, type CommetConfig, CommetError, type CommetGeneratedTypes, CommetValidationError, type CreateBatchUsageEventsParams, type CreateCustomerParams, type CreateSubscriptionParams, type CreateUsageEventParams, type Currency, type Customer, type CustomerID, type Environment, type EventID, type GeneratedEventType, type GeneratedProductId, type GeneratedSeatType, type GetAllBalancesParams, type GetBalanceParams, type InvoiceID, type ItemID, type ListCustomersParams, type ListParams, type ListSeatEventsParams, type ListSubscriptionsParams, type ListUsageEventsParams, type PaginatedList, type PaginatedResponse, type PhaseID, type PortalAccess, type ProductID, type RemoveSeatsParams, type RequestAccessParams, type RequestOptions, type RetrieveOptions, type SeatBalance, type SeatBalanceResponse, type SeatEvent, type SetSeatsParams, type Subscription, type SubscriptionItem, type UpdateCustomerParams, type UsageEvent, type UsageEventProperty, type WebhookData, type WebhookEvent, type WebhookID, type WebhookPayload, Webhooks, Commet as default, isProduction, isSandbox };
+export { type ActiveSubscription, type AddParams as AddSeatsParams, type ApiResponse, type BillingInterval, type CancelParams, type ChangePlanParams, Commet, CommetAPIError, type CommetConfig, CommetError, type CommetGeneratedTypes, CommetValidationError, type CreateParams as CreateCustomerParams, type CreateSubscriptionParams, type Currency, type Customer, type CustomerAddress, type CustomerID, type BatchResult$1 as CustomersBatchResult, type Environment, type EventID, type FeatureSummary, type FeatureType, type GeneratedEventType, type GeneratedFeatureCode, type GeneratedPlanCode, type GeneratedSeatType, type GetAllBalancesParams, type GetBalanceParams, type GetSubscriptionParams, type GetUrlParams, type ListCustomersParams, type ListPlansParams, type PaginatedList, type PaginatedResponse, type Plan, type PlanDetail, type PlanFeature, type PlanID, type PlanPrice, type PortalAccess, type RemoveParams as RemoveSeatsParams, type RequestOptions, type SeatBalance, type SeatEvent, type SetAllParams as SetAllSeatsParams, type SetParams as SetSeatsParams, type Subscription, type SubscriptionStatus, type TrackParams, type UpdateParams as UpdateCustomerParams, type BatchResult as UsageBatchResult, type UsageEvent, type UsageEventProperty, type WebhookData, type WebhookEvent, type WebhookPayload, Webhooks, Commet as default, isProduction, isSandbox };