@commet/node 1.0.1 → 1.1.0

package/dist/index.d.ts

@@ -129,222 +129,89 @@ declare class CommetHTTPClient {
     private sleep;
 }
 
-interface Customer {
-    id: CustomerID;
-    organizationId: string;
-    externalId?: string;
-    legalName?: string;
-    displayName?: string;
-    domain?: string;
-    website?: string;
-    billingEmail: string;
-    timezone?: string;
-    language?: string;
-    industry?: string;
-    employeeCount?: string;
-    metadata?: Record<string, unknown>;
-    isActive: boolean;
-    createdAt: string;
-    updatedAt: string;
-}
-interface CustomerAddress {
-    line1: string;
-    line2?: string;
-    city: string;
-    state?: string;
-    postalCode: string;
-    country: string;
-}
-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;
-}
-interface UpdateParams {
-    externalId?: string;
-    email?: string;
-    legalName?: string;
-    displayName?: string;
-    domain?: string;
-    website?: string;
-    timezone?: string;
-    language?: string;
-    industry?: string;
-    metadata?: Record<string, unknown>;
-}
-interface ListCustomersParams extends ListParams {
-    externalId?: string;
-    isActive?: boolean;
-    search?: string;
-}
-interface BatchResult$1 {
-    successful: Customer[];
-    failed: Array<{
-        index: number;
-        error: string;
-        data: CreateParams;
-    }>;
-}
-/**
- * Customers resource - Manage your customers
- */
-declare class CustomersResource {
-    private httpClient;
-    constructor(httpClient: CommetHTTPClient);
-    /**
-     * 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[]>>;
-    /**
-     * Archive a 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 {
+interface FeatureAccess {
     code: string;
     name: string;
-    type: FeatureType;
+    type: "boolean" | "metered" | "seats";
+    allowed: boolean;
     enabled?: boolean;
-    includedAmount?: number;
+    current?: number;
+    included?: number;
+    remaining?: number;
+    overage?: number;
+    overageUnitPrice?: 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 CanUseResult {
+    allowed: boolean;
+    willBeCharged: boolean;
+    reason?: string;
 }
-interface ListPlansParams extends ListParams {
-    includePrivate?: boolean;
+interface CheckResult {
+    allowed: boolean;
 }
 /**
- * Plans resource for listing available plans
+ * Features resource for checking feature access and usage
+ *
+ * Provides a clean API to check if a customer can use a feature
+ * without having to manually parse subscription data.
  */
-declare class PlansResource {
+declare class FeaturesResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
     /**
-     * List all available plans
+     * Get detailed feature access/usage for a customer
      *
      * @example
      * ```typescript
-     * // List public plans
-     * const plans = await commet.plans.list();
+     * const seats = await commet.features.get("team_members", "user_123");
+     * console.log(seats.current, seats.included, seats.remaining);
+     * ```
+     */
+    get(code: GeneratedFeatureCode, externalId: string, options?: RequestOptions): Promise<ApiResponse<FeatureAccess>>;
+    /**
+     * Check if a boolean feature is enabled for a customer
      *
-     * // Include private plans
-     * const allPlans = await commet.plans.list({ includePrivate: true });
+     * @example
+     * ```typescript
+     * const { allowed } = await commet.features.check("custom_branding", "user_123");
+     * if (!allowed) redirect("/upgrade");
      * ```
      */
-    list(params?: ListPlansParams): Promise<ApiResponse<Plan[]>>;
+    check(code: GeneratedFeatureCode, externalId: string, options?: RequestOptions): Promise<ApiResponse<CheckResult>>;
     /**
-     * Get a specific plan by code
+     * Check if customer can use one more unit of a feature
+     *
+     * Returns whether the customer can add one more (allowed)
+     * and whether they'll be charged extra (willBeCharged).
      *
      * @example
      * ```typescript
-     * const plan = await commet.plans.get('pro');
-     * console.log(plan.data.name); // "Pro"
-     * console.log(plan.data.prices); // [{ billingInterval: 'monthly', price: 9900 }]
+     * const { allowed, willBeCharged } = await commet.features.canUse("team_members", "user_123");
+     *
+     * if (!allowed) {
+     *   return { error: "Upgrade to add more members" };
+     * }
+     *
+     * if (willBeCharged) {
+     *   // Show confirmation: "This will cost $10/month extra"
+     * }
      * ```
      */
-    get(planCode: GeneratedPlanCode): Promise<ApiResponse<PlanDetail>>;
-}
-
-interface PortalAccess {
-    success: boolean;
-    message: string;
-    portalUrl: string;
-}
-interface GetUrlByCustomerId {
-    customerId: CustomerID;
-    email?: never;
-    externalId?: never;
-}
-interface GetUrlByExternalId {
-    externalId: string;
-    email?: never;
-    customerId?: never;
-}
-interface GetUrlByEmail {
-    email: string;
-    customerId?: never;
-    externalId?: never;
-}
-type GetUrlParams = GetUrlByCustomerId | GetUrlByExternalId | GetUrlByEmail;
-/**
- * Portal resource - Generate customer portal access
- */
-declare class PortalResource {
-    private httpClient;
-    constructor(httpClient: CommetHTTPClient);
+    canUse(code: GeneratedFeatureCode, externalId: string, options?: RequestOptions): Promise<ApiResponse<CanUseResult>>;
     /**
-     * Get a portal URL
+     * List all features for a customer's active subscription
      *
      * @example
      * ```typescript
-     * const portal = await commet.portal.getUrl({ externalId: 'user_123' });
+     * const features = await commet.features.list("user_123");
+     * for (const feature of features) {
+     *   console.log(feature.code, feature.allowed);
+     * }
      * ```
      */
-    getUrl(params: GetUrlParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
+    list(externalId: string, options?: RequestOptions): Promise<ApiResponse<FeatureAccess[]>>;
 }
 
 interface SeatEvent {
@@ -441,40 +308,194 @@ declare class SeatsResource {
      */
     set(params: SetParams, options?: RequestOptions): Promise<ApiResponse<SeatEvent>>;
     /**
-     * Set all seat types
+     * 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 UsageEvent {
+    id: EventID;
+    organizationId: string;
+    customerId: CustomerID;
+    eventType: GeneratedEventType;
+    idempotencyKey?: string;
+    ts: string;
+    properties?: UsageEventProperty[];
+    createdAt: string;
+}
+interface UsageEventProperty {
+    id: string;
+    usageEventId: EventID;
+    property: string;
+    value: string;
+    createdAt: string;
+}
+interface BatchResult$1<T> {
+    successful: T[];
+    failed: Array<{
+        index: number;
+        error: string;
+        data: TrackParams;
+    }>;
+}
+interface TrackParams {
+    eventType: GeneratedEventType;
+    customerId?: CustomerID;
+    externalId?: string;
+    idempotencyKey?: string;
+    value?: number;
+    timestamp?: string;
+    properties?: Record<string, string>;
+}
+/**
+ * Usage resource - Track consumption events for usage-based billing
+ */
+declare class UsageResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    /**
+     * 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$1<UsageEvent>>>;
+}
+
+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;
+}
+/**
+ * Plans resource for listing available plans
+ */
+declare class PlansResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    /**
+     * List all available plans
      *
      * @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
+     * // List public plans
+     * const plans = await commet.plans.list();
      *
-     * @example
-     * ```typescript
-     * const balance = await commet.seats.getBalance({
-     *   externalId: 'user_123',
-     *   seatType: 'editor'
-     * });
+     * // Include private plans
+     * const allPlans = await commet.plans.list({ includePrivate: true });
      * ```
      */
-    getBalance(params: GetBalanceParams): Promise<ApiResponse<SeatBalance>>;
+    list(params?: ListPlansParams): Promise<ApiResponse<Plan[]>>;
     /**
-     * Get all seat balances
+     * Get a specific plan by code
      *
      * @example
      * ```typescript
-     * const balances = await commet.seats.getAllBalances({
-     *   externalId: 'user_123'
-     * });
+     * const plan = await commet.plans.get('pro');
+     * console.log(plan.data.name); // "Pro"
+     * console.log(plan.data.prices); // [{ billingInterval: 'monthly', price: 9900 }]
      * ```
      */
-    getAllBalances(params: GetAllBalancesParams): Promise<ApiResponse<Record<string, SeatBalance>>>;
+    get(planCode: GeneratedPlanCode): Promise<ApiResponse<PlanDetail>>;
 }
 
 type SubscriptionStatus = "draft" | "pending_payment" | "trialing" | "active" | "paused" | "past_due" | "canceled" | "expired";
@@ -487,6 +508,7 @@ interface FeatureSummary {
         current: number;
         included: number;
         overage: number;
+        overageUnitPrice?: number;
     };
 }
 interface ActiveSubscription {
@@ -619,76 +641,238 @@ declare class SubscriptionsResource {
     cancel(subscriptionId: string, params?: CancelParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
 }
 
-interface UsageEvent {
-    id: EventID;
-    organizationId: string;
+interface PortalAccess {
+    success: boolean;
+    message: string;
+    portalUrl: string;
+}
+interface GetUrlByCustomerId {
     customerId: CustomerID;
-    eventType: GeneratedEventType;
-    idempotencyKey?: string;
-    ts: string;
-    properties?: UsageEventProperty[];
-    createdAt: string;
+    email?: never;
+    externalId?: never;
 }
-interface UsageEventProperty {
-    id: string;
-    usageEventId: EventID;
-    property: string;
-    value: string;
+interface GetUrlByExternalId {
+    externalId: string;
+    email?: never;
+    customerId?: never;
+}
+interface GetUrlByEmail {
+    email: string;
+    customerId?: never;
+    externalId?: never;
+}
+type GetUrlParams = GetUrlByCustomerId | GetUrlByExternalId | GetUrlByEmail;
+/**
+ * Portal resource - Generate customer portal access
+ */
+declare class PortalResource {
+    private httpClient;
+    constructor(httpClient: CommetHTTPClient);
+    /**
+     * Get a portal URL
+     *
+     * @example
+     * ```typescript
+     * const portal = await commet.portal.getUrl({ externalId: 'user_123' });
+     * ```
+     */
+    getUrl(params: GetUrlParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
+}
+
+/**
+ * Customer-scoped API context
+ *
+ * Provides a cleaner API where you don't have to pass externalId
+ * on every call. All operations are scoped to a specific customer.
+ *
+ * @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");
+ * ```
+ */
+declare class CustomerContext {
+    private readonly externalId;
+    private readonly httpClient;
+    constructor(httpClient: CommetHTTPClient, externalId: string);
+    /**
+     * Feature access methods - check what the customer can use
+     */
+    features: {
+        /**
+         * Get detailed feature access/usage
+         */
+        get: (code: GeneratedFeatureCode, options?: RequestOptions) => Promise<ApiResponse<FeatureAccess>>;
+        /**
+         * Check if a boolean feature is enabled
+         */
+        check: (code: GeneratedFeatureCode, options?: RequestOptions) => Promise<ApiResponse<CheckResult>>;
+        /**
+         * Check if customer can use one more unit
+         */
+        canUse: (code: GeneratedFeatureCode, options?: RequestOptions) => Promise<ApiResponse<CanUseResult>>;
+        /**
+         * List all features
+         */
+        list: (options?: RequestOptions) => Promise<ApiResponse<FeatureAccess[]>>;
+    };
+    /**
+     * Seat management methods
+     */
+    seats: {
+        /**
+         * Add seats
+         */
+        add: (seatType: GeneratedSeatType, count?: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
+        /**
+         * Remove seats
+         */
+        remove: (seatType: GeneratedSeatType, count?: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
+        /**
+         * Set total seat count
+         */
+        set: (seatType: GeneratedSeatType, count: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
+        /**
+         * Get current seat balance
+         */
+        getBalance: (seatType: GeneratedSeatType, options?: RequestOptions) => Promise<ApiResponse<SeatBalance>>;
+    };
+    /**
+     * Usage tracking methods
+     */
+    usage: {
+        /**
+         * Track a usage event
+         */
+        track: (eventType: GeneratedEventType, properties?: Record<string, string>, options?: RequestOptions) => Promise<ApiResponse<UsageEvent>>;
+    };
+    /**
+     * Subscription methods
+     */
+    subscription: {
+        /**
+         * Get active subscription
+         */
+        get: (options?: RequestOptions) => Promise<ApiResponse<ActiveSubscription | null>>;
+        /**
+         * Cancel subscription
+         */
+        cancel: (params?: {
+            reason?: string;
+            immediate?: boolean;
+        }, options?: RequestOptions) => Promise<ApiResponse<Subscription>>;
+    };
+    /**
+     * Portal methods
+     */
+    portal: {
+        /**
+         * Get customer portal URL
+         */
+        getUrl: (options?: RequestOptions) => Promise<ApiResponse<PortalAccess>>;
+    };
+}
+
+interface Customer {
+    id: CustomerID;
+    organizationId: string;
+    externalId?: string;
+    legalName?: string;
+    displayName?: string;
+    domain?: string;
+    website?: string;
+    billingEmail: string;
+    timezone?: string;
+    language?: string;
+    industry?: string;
+    employeeCount?: string;
+    metadata?: Record<string, unknown>;
+    isActive: boolean;
     createdAt: string;
+    updatedAt: string;
 }
-interface BatchResult<T> {
-    successful: T[];
+interface CustomerAddress {
+    line1: string;
+    line2?: string;
+    city: string;
+    state?: string;
+    postalCode: string;
+    country: string;
+}
+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;
+}
+interface UpdateParams {
+    externalId?: string;
+    email?: string;
+    legalName?: string;
+    displayName?: string;
+    domain?: string;
+    website?: string;
+    timezone?: string;
+    language?: string;
+    industry?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ListCustomersParams extends ListParams {
+    externalId?: string;
+    isActive?: boolean;
+    search?: string;
+}
+interface BatchResult {
+    successful: Customer[];
     failed: Array<{
         index: number;
         error: string;
-        data: TrackParams;
+        data: CreateParams;
     }>;
 }
-interface TrackParams {
-    eventType: GeneratedEventType;
-    customerId?: CustomerID;
-    externalId?: string;
-    idempotencyKey?: string;
-    value?: number;
-    timestamp?: string;
-    properties?: Record<string, string>;
-}
 /**
- * Usage resource - Track consumption events for usage-based billing
+ * Customers resource - Manage your customers
  */
-declare class UsageResource {
+declare class CustomersResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
     /**
-     * Track a usage event
-     *
-     * @example
-     * ```typescript
-     * await commet.usage.track({
-     *   externalId: 'user_123',
-     *   eventType: 'api_call',
-     *   idempotencyKey: `evt_${requestId}`,
-     *   properties: { endpoint: '/users', method: 'GET' }
-     * });
-     * ```
+     * Create a customer (idempotent with externalId)
      */
-    track(params: TrackParams, options?: RequestOptions): Promise<ApiResponse<UsageEvent>>;
+    create(params: CreateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
     /**
-     * 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' }
-     *   ]
-     * });
-     * ```
+     * Create multiple customers in batch
      */
-    trackBatch(params: {
-        events: TrackParams[];
-    }, options?: RequestOptions): Promise<ApiResponse<BatchResult<UsageEvent>>>;
+    createBatch(params: {
+        customers: CreateParams[];
+    }, options?: RequestOptions): Promise<ApiResponse<BatchResult>>;
+    /**
+     * 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[]>>;
+    /**
+     * Archive a customer
+     */
+    archive(customerId: CustomerID, options?: RequestOptions): Promise<ApiResponse<Customer>>;
 }
 
 /**
@@ -802,8 +986,23 @@ declare class Commet {
     readonly seats: SeatsResource;
     readonly subscriptions: SubscriptionsResource;
     readonly portal: PortalResource;
+    readonly features: FeaturesResource;
     readonly webhooks: Webhooks;
     constructor(config: CommetConfig);
+    /**
+     * 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(externalId: string): CustomerContext;
     getEnvironment(): Environment;
     isSandbox(): boolean;
     isProduction(): boolean;
@@ -822,4 +1021,4 @@ declare function isProduction(environment: Environment): boolean;
  * Commet SDK - Billing and usage tracking for SaaS
  */
 
-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 };
+export { type ActiveSubscription, type AddParams as AddSeatsParams, type ApiResponse, type BillingInterval, type CanUseResult, type CancelParams, type ChangePlanParams, type CheckResult, Commet, CommetAPIError, type CommetConfig, CommetError, type CommetGeneratedTypes, CommetValidationError, type CreateParams as CreateCustomerParams, type CreateSubscriptionParams, type Currency, type Customer, type CustomerAddress, CustomerContext, type CustomerID, type BatchResult as CustomersBatchResult, type Environment, type EventID, type FeatureAccess, 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$1 as UsageBatchResult, type UsageEvent, type UsageEventProperty, type WebhookData, type WebhookEvent, type WebhookPayload, Webhooks, Commet as default, isProduction, isSandbox };