@commet/node 1.1.0 → 1.2.0

package/dist/index.d.ts

@@ -129,6 +129,13 @@ declare class CommetHTTPClient {
     private sleep;
 }
 
+interface FeatureParams {
+    externalId: string;
+    code: GeneratedFeatureCode;
+}
+type GetFeatureParams = FeatureParams;
+type CheckFeatureParams = FeatureParams;
+type CanUseFeatureParams = FeatureParams;
 interface FeatureAccess {
     code: string;
     name: string;
@@ -165,21 +172,24 @@ declare class FeaturesResource {
      *
      * @example
      * ```typescript
-     * const seats = await commet.features.get("team_members", "user_123");
+     * const seats = await commet.features.get({ code: "team_members", externalId: "user_123" });
      * console.log(seats.current, seats.included, seats.remaining);
      * ```
      */
-    get(code: GeneratedFeatureCode, externalId: string, options?: RequestOptions): Promise<ApiResponse<FeatureAccess>>;
+    get(params: GetFeatureParams, options?: RequestOptions): Promise<ApiResponse<FeatureAccess>>;
     /**
      * Check if a boolean feature is enabled for a customer
      *
      * @example
      * ```typescript
-     * const { allowed } = await commet.features.check("custom_branding", "user_123");
+     * const { allowed } = await commet.features.check({
+     *   code: "custom_branding",
+     *   externalId: "user_123"
+     * });
      * if (!allowed) redirect("/upgrade");
      * ```
      */
-    check(code: GeneratedFeatureCode, externalId: string, options?: RequestOptions): Promise<ApiResponse<CheckResult>>;
+    check(params: CheckFeatureParams, options?: RequestOptions): Promise<ApiResponse<CheckResult>>;
     /**
      * Check if customer can use one more unit of a feature
      *
@@ -188,7 +198,10 @@ declare class FeaturesResource {
      *
      * @example
      * ```typescript
-     * const { allowed, willBeCharged } = await commet.features.canUse("team_members", "user_123");
+     * const { allowed, willBeCharged } = await commet.features.canUse({
+     *   code: "team_members",
+     *   externalId: "user_123"
+     * });
      *
      * if (!allowed) {
      *   return { error: "Upgrade to add more members" };
@@ -199,13 +212,13 @@ declare class FeaturesResource {
      * }
      * ```
      */
-    canUse(code: GeneratedFeatureCode, externalId: string, options?: RequestOptions): Promise<ApiResponse<CanUseResult>>;
+    canUse(params: CanUseFeatureParams, options?: RequestOptions): Promise<ApiResponse<CanUseResult>>;
     /**
      * List all features for a customer's active subscription
      *
      * @example
      * ```typescript
-     * const features = await commet.features.list("user_123");
+     * const features = await commet.features.list({ externalId: "user_123" });
      * for (const feature of features) {
      *   console.log(feature.code, feature.allowed);
      * }
@@ -214,6 +227,44 @@ declare class FeaturesResource {
     list(externalId: string, options?: RequestOptions): Promise<ApiResponse<FeatureAccess[]>>;
 }
 
+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);
+    /**
+     * Get a portal URL
+     *
+     * @example
+     * ```typescript
+     * const portal = await commet.portal.getUrl({ externalId: 'user_123' });
+     * ```
+     */
+    getUrl(params: GetUrlParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
+}
+
 interface SeatEvent {
     id: string;
     organizationId: string;
@@ -344,78 +395,6 @@ declare class SeatsResource {
     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";
@@ -579,13 +558,14 @@ type CreateSubscriptionParams = CustomerIdentifier & PlanIdentifier & {
     startDate?: string;
 };
 type ChangePlanParams = PlanIdentifier & {
+    subscriptionId: string;
     billingInterval?: BillingInterval;
 };
 interface CancelParams {
+    subscriptionId: string;
     reason?: string;
     immediate?: boolean;
 }
-type GetSubscriptionParams = CustomerIdentifier;
 /**
  * Subscription resource for managing subscriptions (plan-first model)
  *
@@ -613,70 +593,106 @@ declare class SubscriptionsResource {
      *
      * @example
      * ```typescript
-     * const sub = await commet.subscriptions.get({ externalId: 'user_123' });
+     * const sub = await commet.subscriptions.get('user_123');
      * ```
      */
-    get(params: GetSubscriptionParams): Promise<ApiResponse<ActiveSubscription | null>>;
+    get(externalId: string): Promise<ApiResponse<ActiveSubscription | null>>;
     /**
      * Change the plan of a subscription (upgrade/downgrade)
      *
      * @example
      * ```typescript
-     * await commet.subscriptions.changePlan('sub_xxx', {
+     * await commet.subscriptions.changePlan({
+     *   subscriptionId: 'sub_xxx',
      *   planCode: 'enterprise' // autocomplete works after `commet pull`
      * });
      * ```
      */
-    changePlan(subscriptionId: string, params: ChangePlanParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
+    changePlan(params: ChangePlanParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
     /**
      * Cancel a subscription
      *
      * @example
      * ```typescript
-     * await commet.subscriptions.cancel('sub_xxx', {
+     * await commet.subscriptions.cancel({
+     *   subscriptionId: 'sub_xxx',
      *   reason: 'switched_to_competitor'
      * });
      * ```
      */
-    cancel(subscriptionId: string, params?: CancelParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
+    cancel(params: CancelParams, options?: RequestOptions): Promise<ApiResponse<Subscription>>;
 }
 
-interface PortalAccess {
-    success: boolean;
-    message: string;
-    portalUrl: string;
-}
-interface GetUrlByCustomerId {
+interface UsageEvent {
+    id: EventID;
+    organizationId: string;
     customerId: CustomerID;
-    email?: never;
-    externalId?: never;
+    eventType: GeneratedEventType;
+    idempotencyKey?: string;
+    ts: string;
+    properties?: UsageEventProperty[];
+    createdAt: string;
 }
-interface GetUrlByExternalId {
-    externalId: string;
-    email?: never;
-    customerId?: never;
+interface UsageEventProperty {
+    id: string;
+    usageEventId: EventID;
+    property: string;
+    value: string;
+    createdAt: string;
 }
-interface GetUrlByEmail {
-    email: string;
-    customerId?: never;
-    externalId?: never;
+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>;
 }
-type GetUrlParams = GetUrlByCustomerId | GetUrlByExternalId | GetUrlByEmail;
 /**
- * Portal resource - Generate customer portal access
+ * Usage resource - Track consumption events for usage-based billing
  */
-declare class PortalResource {
+declare class UsageResource {
     private httpClient;
     constructor(httpClient: CommetHTTPClient);
     /**
-     * Get a portal URL
+     * Track a usage event
      *
      * @example
      * ```typescript
-     * const portal = await commet.portal.getUrl({ externalId: 'user_123' });
+     * await commet.usage.track({
+     *   externalId: 'user_123',
+     *   eventType: 'api_call',
+     *   idempotencyKey: `evt_${requestId}`,
+     *   properties: { endpoint: '/users', method: 'GET' }
+     * });
      * ```
      */
-    getUrl(params: GetUrlParams, options?: RequestOptions): Promise<ApiResponse<PortalAccess>>;
+    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>>>;
 }
 
 /**
@@ -697,82 +713,52 @@ declare class PortalResource {
  */
 declare class CustomerContext {
     private readonly externalId;
-    private readonly httpClient;
-    constructor(httpClient: CommetHTTPClient, externalId: string);
-    /**
-     * Feature access methods - check what the customer can use
+    private readonly featuresResource;
+    private readonly seatsResource;
+    private readonly usageResource;
+    private readonly subscriptionsResource;
+    private readonly portalResource;
+    constructor(externalId: string, resources: {
+        features: FeaturesResource;
+        seats: SeatsResource;
+        usage: UsageResource;
+        subscriptions: SubscriptionsResource;
+        portal: PortalResource;
+    });
+    /**
+     * Feature access methods - delegates to FeaturesResource
      */
     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
-         */
+        get: (code: string, options?: RequestOptions) => Promise<ApiResponse<FeatureAccess>>;
+        check: (code: string, options?: RequestOptions) => Promise<ApiResponse<CheckResult>>;
+        canUse: (code: string, options?: RequestOptions) => Promise<ApiResponse<CanUseResult>>;
         list: (options?: RequestOptions) => Promise<ApiResponse<FeatureAccess[]>>;
     };
     /**
-     * Seat management methods
+     * Seat management methods - delegates to SeatsResource
      */
     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>>;
+        add: (seatType: string, count?: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
+        remove: (seatType: string, count?: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
+        set: (seatType: string, count: number, options?: RequestOptions) => Promise<ApiResponse<SeatEvent>>;
+        getBalance: (seatType: string) => Promise<ApiResponse<SeatBalance>>;
     };
     /**
-     * Usage tracking methods
+     * Usage tracking methods - delegates to UsageResource
      */
     usage: {
-        /**
-         * Track a usage event
-         */
-        track: (eventType: GeneratedEventType, properties?: Record<string, string>, options?: RequestOptions) => Promise<ApiResponse<UsageEvent>>;
+        track: (eventType: string, properties?: Record<string, string>, options?: RequestOptions) => Promise<ApiResponse<UsageEvent>>;
     };
     /**
-     * Subscription methods
+     * Subscription methods - delegates to SubscriptionsResource
      */
     subscription: {
-        /**
-         * Get active subscription
-         */
-        get: (options?: RequestOptions) => Promise<ApiResponse<ActiveSubscription | null>>;
-        /**
-         * Cancel subscription
-         */
-        cancel: (params?: {
-            reason?: string;
-            immediate?: boolean;
-        }, options?: RequestOptions) => Promise<ApiResponse<Subscription>>;
+        get: () => Promise<ApiResponse<ActiveSubscription | null>>;
     };
     /**
-     * Portal methods
+     * Portal methods - delegates to PortalResource
      */
     portal: {
-        /**
-         * Get customer portal URL
-         */
         getUrl: (options?: RequestOptions) => Promise<ApiResponse<PortalAccess>>;
     };
 }
@@ -817,6 +803,7 @@ interface CreateParams {
     address?: CustomerAddress;
 }
 interface UpdateParams {
+    customerId: CustomerID;
     externalId?: string;
     email?: string;
     legalName?: string;
@@ -864,7 +851,7 @@ declare class CustomersResource {
     /**
      * Update a customer
      */
-    update(customerId: CustomerID, params: UpdateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
+    update(params: UpdateParams, options?: RequestOptions): Promise<ApiResponse<Customer>>;
     /**
      * List customers with optional filters
      */
@@ -902,6 +889,16 @@ interface WebhookData {
  * Supported webhook events
  */
 type WebhookEvent = "subscription.created" | "subscription.activated" | "subscription.canceled" | "subscription.updated";
+interface VerifyParams {
+    payload: string;
+    signature: string | null;
+    secret: string;
+}
+interface VerifyAndParseParams {
+    rawBody: string;
+    signature: string | null;
+    secret: string;
+}
 /**
  * Webhooks resource for signature verification
  */
@@ -939,7 +936,7 @@ declare class Webhooks {
      * }
      * ```
      */
-    verify(payload: string, signature: string | null, secret: string): boolean;
+    verify(params: VerifyParams): boolean;
     /**
      * Generate HMAC-SHA256 signature (internal use)
      * @internal
@@ -948,18 +945,13 @@ declare class Webhooks {
     /**
      * Parse and verify webhook payload in one step
      *
-     * @param rawBody - Raw request body as string
-     * @param signature - Value from X-Commet-Signature header
-     * @param secret - Your webhook secret from Commet dashboard
-     * @returns Parsed payload if valid, null if invalid
-     *
      * @example
      * ```typescript
-     * const payload = commet.webhooks.verifyAndParse(
+     * const payload = commet.webhooks.verifyAndParse({
      *   rawBody,
      *   signature,
-     *   process.env.COMMET_WEBHOOK_SECRET
-     * );
+     *   secret: process.env.COMMET_WEBHOOK_SECRET
+     * });
      *
      * if (!payload) {
      *   return new Response('Invalid signature', { status: 401 });
@@ -971,7 +963,7 @@ declare class Webhooks {
      * }
      * ```
      */
-    verifyAndParse(rawBody: string, signature: string | null, secret: string): WebhookPayload | null;
+    verifyAndParse(params: VerifyAndParseParams): WebhookPayload | null;
 }
 
 /**
@@ -1021,4 +1013,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 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 };
+export { type ActiveSubscription, type AddParams as AddSeatsParams, type ApiResponse, type BillingInterval, type CanUseFeatureParams, type CanUseResult, type CancelParams, type ChangePlanParams, type CheckFeatureParams, 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 GetFeatureParams, 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 };