autumn-js 0.1.11 → 0.1.12

package/dist/sdk/index.d.ts

@@ -487,6 +487,8 @@ declare const CheckoutParamsSchema: z.ZodObject<{
         feature_id: z.ZodString;
         quantity: z.ZodNumber;
     }, z.core.$strip>>>;
+    force_checkout: z.ZodOptional<z.ZodBoolean>;
+    invoice: z.ZodOptional<z.ZodBoolean>;
     success_url: z.ZodOptional<z.ZodString>;
     customer_data: z.ZodOptional<z.ZodObject<{
         name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -670,9 +672,63 @@ declare class Autumn {
             list: Feature[];
         }, AutumnError>>;
     };
-    static checkout: (params: CheckoutParams) => Promise<Result<CheckoutResult, AutumnError>>;
+    /**
+     * Initiates a checkout flow for a product purchase.
+     *
+     * The checkout function handles the purchase process for products with pricing.
+     * It determines whether to show a dialog for user input or redirect directly
+     * to Stripe based on the customer's state and product requirements.
+     *
+     * @param params - Checkout parameters including product ID, customer data, and options
+     * @returns Promise resolving to checkout details including pricing, prorations, and URLs
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.checkout({
+     *   customer_id: "user_123",
+     *   product_id: "pro",
+     *   success_url: "https://myapp.com/success"
+     * });
+     *
+     * if (result.url) {
+     *   // Redirect to Stripe checkout
+     *   window.location.href = result.url;
+     * }
+     * ```
+     */
     checkout(params: CheckoutParams): Promise<Result<CheckoutResult, AutumnError>>;
-    static attach: (params: AttachParams) => Promise<Result<{
+    static checkout: (params: CheckoutParams) => Promise<Result<CheckoutResult, AutumnError>>;
+    static usage: (params: UsageParams) => Promise<Result<UsageResult, AutumnError>>;
+    /**
+     * Attaches a product to a customer, enabling access and handling billing.
+     *
+     * The attach function activates a product for a customer and applies all product items.
+     * When you attach a product:
+     * - The customer gains access to all features in the product
+     * - If the product has prices, the customer will be billed accordingly
+     * - If there's no existing payment method, a checkout URL will be generated
+     *
+     * @param params - Attach parameters including customer ID, product ID, and options
+     * @returns Promise resolving to attachment result with checkout URL if needed
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.attach({
+     *   customer_id: "user_123",
+     *   product_id: "pro",
+     *   success_url: "https://myapp.com/success"
+     * });
+     *
+     * if (result.checkout_url) {
+     *   // Payment required - redirect to checkout
+     *   window.location.href = result.checkout_url;
+     * } else {
+     *   // Product successfully attached
+     *   console.log("Access granted:", result.message);
+     * }
+     * ```
+     */
+    attach(params: AttachParams): Promise<Result<{
         customer_id: string;
         product_ids: string[];
         code: string;
@@ -687,8 +743,7 @@ declare class Autumn {
             currency: string;
         } | undefined;
     }, AutumnError>>;
-    static usage: (params: UsageParams) => Promise<Result<UsageResult, AutumnError>>;
-    attach(params: AttachParams): Promise<Result<{
+    static attach: (params: AttachParams) => Promise<Result<{
         customer_id: string;
         product_ids: string[];
         code: string;
@@ -704,18 +759,76 @@ declare class Autumn {
         } | undefined;
     }, AutumnError>>;
     static setupPayment: (params: SetupPaymentParams) => Promise<Result<SetupPaymentResult, AutumnError>>;
+    /**
+     * Sets up a payment method for a customer.
+     *
+     * This method allows you to set up payment methods for customers without
+     * immediately charging them. Useful for collecting payment information
+     * before product attachment or for updating existing payment methods.
+     *
+     * @param params - Setup payment parameters including customer information
+     * @returns Promise resolving to setup payment result
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.setupPayment({
+     *   customer_id: "user_123"
+     * });
+     * ```
+     */
     setupPayment(params: SetupPaymentParams): Promise<Result<SetupPaymentResult, AutumnError>>;
     static cancel: (params: CancelParams) => Promise<Result<{
         success: boolean;
         customer_id: string;
         product_id: string;
     }, AutumnError>>;
+    /**
+     * Cancels a customer's subscription or product attachment.
+     *
+     * This method allows you to cancel a customer's subscription to a specific product.
+     * You can choose to cancel immediately or at the end of the billing cycle.
+     *
+     * @param params - Cancel parameters including customer ID and product ID
+     * @returns Promise resolving to cancellation result
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.cancel({
+     *   customer_id: "user_123",
+     *   product_id: "pro",
+     *   cancel_immediately: false // Cancel at end of billing cycle
+     * });
+     * ```
+     */
     cancel(params: CancelParams): Promise<Result<{
         success: boolean;
         customer_id: string;
         product_id: string;
     }, AutumnError>>;
     static check: (params: CheckParams) => Promise<Result<CheckResult, AutumnError>>;
+    /**
+     * Checks if a customer has access to a specific feature.
+     *
+     * This method verifies whether a customer has permission to use a feature
+     * and checks their remaining balance/usage limits. It can be used to gate
+     * features and determine when to show upgrade prompts.
+     *
+     * @param params - Check parameters including customer ID and feature ID
+     * @returns Promise resolving to access check result with allowed status and balance info
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.check({
+     *   customer_id: "user_123",
+     *   feature_id: "messages",
+     *   required_balance: 1
+     * });
+     *
+     * if (!result.allowed) {
+     *   console.log("Feature access denied - upgrade required");
+     * }
+     * ```
+     */
     check(params: CheckParams): Promise<Result<CheckResult, AutumnError>>;
     static track: (params: TrackParams) => Promise<Result<{
         id: string;
@@ -724,6 +837,25 @@ declare class Autumn {
         feature_id?: string | undefined;
         event_name?: string | undefined;
     }, AutumnError>>;
+    /**
+     * Tracks usage events for features or analytics.
+     *
+     * This method records usage events for metered features, updating the customer's
+     * balance and usage statistics. It's typically used server-side to ensure
+     * accurate tracking that cannot be manipulated by users.
+     *
+     * @param params - Track parameters including customer ID, feature ID, and usage value
+     * @returns Promise resolving to tracking result
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.track({
+     *   customer_id: "user_123",
+     *   feature_id: "messages",
+     *   value: 1 // Track 1 message sent
+     * });
+     * ```
+     */
     track(params: TrackParams): Promise<Result<{
         id: string;
         code: string;
@@ -731,8 +863,46 @@ declare class Autumn {
         feature_id?: string | undefined;
         event_name?: string | undefined;
     }, AutumnError>>;
+    /**
+     * Retrieves usage statistics and analytics for a customer.
+     *
+     * This method fetches detailed usage information for a customer's features,
+     * including current balances, usage history, and analytics data. Useful
+     * for displaying usage dashboards or generating reports.
+     *
+     * @param params - Usage parameters including customer ID and optional filters
+     * @returns Promise resolving to usage statistics and analytics data
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.usage({
+     *   customer_id: "user_123",
+     *   feature_id: "messages"
+     *   value: 20 // Usage value
+     * });
+     * ```
+     */
     usage(params: UsageParams): Promise<Result<UsageResult, AutumnError>>;
     static query: (params: QueryParams) => Promise<Result<QueryResult, AutumnError>>;
+    /**
+     * Performs advanced queries on customer data and analytics.
+     *
+     * This method allows you to run complex queries against customer data,
+     * usage patterns, and billing information. Useful for generating reports,
+     * analytics, and custom data insights.
+     *
+     * @param params - Query parameters including customer ID and query specifications
+     * @returns Promise resolving to query results with requested data
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.query({
+     *   customer_id: "user_123",
+     *   feature_id: "messages" // feature id to fetch for query, can also be an array
+     * });
+     *
+     * ```
+     */
     query(params: QueryParams): Promise<Result<QueryResult, AutumnError>>;
 }
 

package/dist/sdk/index.js

@@ -433,48 +433,216 @@ var Autumn = class {
     });
     return toContainerResult({ response, logger: this.logger });
   }
+  /**
+   * Initiates a checkout flow for a product purchase.
+   * 
+   * The checkout function handles the purchase process for products with pricing.
+   * It determines whether to show a dialog for user input or redirect directly
+   * to Stripe based on the customer's state and product requirements.
+   * 
+   * @param params - Checkout parameters including product ID, customer data, and options
+   * @returns Promise resolving to checkout details including pricing, prorations, and URLs
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.checkout({
+   *   customer_id: "user_123",
+   *   product_id: "pro",
+   *   success_url: "https://myapp.com/success"
+   * });
+   * 
+   * if (result.url) {
+   *   // Redirect to Stripe checkout
+   *   window.location.href = result.url;
+   * }
+   * ```
+   */
   async checkout(params) {
     return handleCheckout({
       instance: this,
       params
     });
   }
+  /**
+   * Attaches a product to a customer, enabling access and handling billing.
+   * 
+   * The attach function activates a product for a customer and applies all product items.
+   * When you attach a product:
+   * - The customer gains access to all features in the product
+   * - If the product has prices, the customer will be billed accordingly  
+   * - If there's no existing payment method, a checkout URL will be generated
+   * 
+   * @param params - Attach parameters including customer ID, product ID, and options
+   * @returns Promise resolving to attachment result with checkout URL if needed
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.attach({
+   *   customer_id: "user_123",
+   *   product_id: "pro",
+   *   success_url: "https://myapp.com/success"
+   * });
+   * 
+   * if (result.checkout_url) {
+   *   // Payment required - redirect to checkout
+   *   window.location.href = result.checkout_url;
+   * } else {
+   *   // Product successfully attached
+   *   console.log("Access granted:", result.message);
+   * }
+   * ```
+   */
   async attach(params) {
     return handleAttach({
       instance: this,
       params
     });
   }
+  /**
+   * Sets up a payment method for a customer.
+   * 
+   * This method allows you to set up payment methods for customers without 
+   * immediately charging them. Useful for collecting payment information
+   * before product attachment or for updating existing payment methods.
+   * 
+   * @param params - Setup payment parameters including customer information
+   * @returns Promise resolving to setup payment result
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.setupPayment({
+   *   customer_id: "user_123"
+   * });
+   * ```
+   */
   async setupPayment(params) {
     return handleSetupPayment({
       instance: this,
       params
     });
   }
+  /**
+   * Cancels a customer's subscription or product attachment.
+   * 
+   * This method allows you to cancel a customer's subscription to a specific product.
+   * You can choose to cancel immediately or at the end of the billing cycle.
+   * 
+   * @param params - Cancel parameters including customer ID and product ID
+   * @returns Promise resolving to cancellation result
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.cancel({
+   *   customer_id: "user_123",
+   *   product_id: "pro",
+   *   cancel_immediately: false // Cancel at end of billing cycle
+   * });
+   * ```
+   */
   async cancel(params) {
     return handleCancel({
       instance: this,
       params
     });
   }
+  /**
+   * Checks if a customer has access to a specific feature.
+   * 
+   * This method verifies whether a customer has permission to use a feature
+   * and checks their remaining balance/usage limits. It can be used to gate
+   * features and determine when to show upgrade prompts.
+   * 
+   * @param params - Check parameters including customer ID and feature ID
+   * @returns Promise resolving to access check result with allowed status and balance info
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.check({
+   *   customer_id: "user_123",
+   *   feature_id: "messages",
+   *   required_balance: 1
+   * });
+   * 
+   * if (!result.allowed) {
+   *   console.log("Feature access denied - upgrade required");
+   * }
+   * ```
+   */
   async check(params) {
     return handleCheck({
       instance: this,
       params
     });
   }
+  /**
+   * Tracks usage events for features or analytics.
+   * 
+   * This method records usage events for metered features, updating the customer's
+   * balance and usage statistics. It's typically used server-side to ensure
+   * accurate tracking that cannot be manipulated by users.
+   * 
+   * @param params - Track parameters including customer ID, feature ID, and usage value
+   * @returns Promise resolving to tracking result
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.track({
+   *   customer_id: "user_123",
+   *   feature_id: "messages",
+   *   value: 1 // Track 1 message sent
+   * });
+   * ```
+   */
   async track(params) {
     return handleTrack({
       instance: this,
       params
     });
   }
+  /**
+   * Retrieves usage statistics and analytics for a customer.
+   * 
+   * This method fetches detailed usage information for a customer's features,
+   * including current balances, usage history, and analytics data. Useful
+   * for displaying usage dashboards or generating reports.
+   * 
+   * @param params - Usage parameters including customer ID and optional filters
+   * @returns Promise resolving to usage statistics and analytics data
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.usage({
+   *   customer_id: "user_123",
+   *   feature_id: "messages" 
+   *   value: 20 // Usage value
+   * });
+   * ```
+   */
   async usage(params) {
     return handleUsage({
       instance: this,
       params
     });
   }
+  /**
+   * Performs advanced queries on customer data and analytics.
+   * 
+   * This method allows you to run complex queries against customer data,
+   * usage patterns, and billing information. Useful for generating reports,
+   * analytics, and custom data insights.
+   * 
+   * @param params - Query parameters including customer ID and query specifications
+   * @returns Promise resolving to query results with requested data
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.query({
+   *   customer_id: "user_123",
+   *   feature_id: "messages" // feature id to fetch for query, can also be an array
+   * });
+   * 
+   * ```
+   */
   async query(params) {
     return handleQuery({
       instance: this,
@@ -488,8 +656,8 @@ __publicField(Autumn, "entities", entityMethods());
 __publicField(Autumn, "referrals", referralMethods());
 __publicField(Autumn, "features", featureMethods());
 __publicField(Autumn, "checkout", (params) => staticWrapper(handleCheckout, void 0, { params }));
-__publicField(Autumn, "attach", (params) => staticWrapper(handleAttach, void 0, { params }));
 __publicField(Autumn, "usage", (params) => staticWrapper(handleUsage, void 0, { params }));
+__publicField(Autumn, "attach", (params) => staticWrapper(handleAttach, void 0, { params }));
 __publicField(Autumn, "setupPayment", (params) => staticWrapper(handleSetupPayment, void 0, { params }));
 __publicField(Autumn, "cancel", (params) => staticWrapper(handleCancel, void 0, { params }));
 __publicField(Autumn, "check", (params) => staticWrapper(handleCheck, void 0, { params }));
@@ -731,6 +899,8 @@ var CheckoutParamsSchema = v4.z.object({
   product_id: v4.z.string(),
   entity_id: v4.z.string().optional(),
   options: v4.z.array(AttachFeatureOptionsSchema).optional(),
+  force_checkout: v4.z.boolean().optional(),
+  invoice: v4.z.boolean().optional(),
   success_url: v4.z.string().optional(),
   customer_data: CustomerDataSchema.optional(),
   entity_data: v4.z.any().optional(),

package/dist/sdk/index.mjs

@@ -431,48 +431,216 @@ var Autumn = class {
     });
     return toContainerResult({ response, logger: this.logger });
   }
+  /**
+   * Initiates a checkout flow for a product purchase.
+   * 
+   * The checkout function handles the purchase process for products with pricing.
+   * It determines whether to show a dialog for user input or redirect directly
+   * to Stripe based on the customer's state and product requirements.
+   * 
+   * @param params - Checkout parameters including product ID, customer data, and options
+   * @returns Promise resolving to checkout details including pricing, prorations, and URLs
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.checkout({
+   *   customer_id: "user_123",
+   *   product_id: "pro",
+   *   success_url: "https://myapp.com/success"
+   * });
+   * 
+   * if (result.url) {
+   *   // Redirect to Stripe checkout
+   *   window.location.href = result.url;
+   * }
+   * ```
+   */
   async checkout(params) {
     return handleCheckout({
       instance: this,
       params
     });
   }
+  /**
+   * Attaches a product to a customer, enabling access and handling billing.
+   * 
+   * The attach function activates a product for a customer and applies all product items.
+   * When you attach a product:
+   * - The customer gains access to all features in the product
+   * - If the product has prices, the customer will be billed accordingly  
+   * - If there's no existing payment method, a checkout URL will be generated
+   * 
+   * @param params - Attach parameters including customer ID, product ID, and options
+   * @returns Promise resolving to attachment result with checkout URL if needed
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.attach({
+   *   customer_id: "user_123",
+   *   product_id: "pro",
+   *   success_url: "https://myapp.com/success"
+   * });
+   * 
+   * if (result.checkout_url) {
+   *   // Payment required - redirect to checkout
+   *   window.location.href = result.checkout_url;
+   * } else {
+   *   // Product successfully attached
+   *   console.log("Access granted:", result.message);
+   * }
+   * ```
+   */
   async attach(params) {
     return handleAttach({
       instance: this,
       params
     });
   }
+  /**
+   * Sets up a payment method for a customer.
+   * 
+   * This method allows you to set up payment methods for customers without 
+   * immediately charging them. Useful for collecting payment information
+   * before product attachment or for updating existing payment methods.
+   * 
+   * @param params - Setup payment parameters including customer information
+   * @returns Promise resolving to setup payment result
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.setupPayment({
+   *   customer_id: "user_123"
+   * });
+   * ```
+   */
   async setupPayment(params) {
     return handleSetupPayment({
       instance: this,
       params
     });
   }
+  /**
+   * Cancels a customer's subscription or product attachment.
+   * 
+   * This method allows you to cancel a customer's subscription to a specific product.
+   * You can choose to cancel immediately or at the end of the billing cycle.
+   * 
+   * @param params - Cancel parameters including customer ID and product ID
+   * @returns Promise resolving to cancellation result
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.cancel({
+   *   customer_id: "user_123",
+   *   product_id: "pro",
+   *   cancel_immediately: false // Cancel at end of billing cycle
+   * });
+   * ```
+   */
   async cancel(params) {
     return handleCancel({
       instance: this,
       params
     });
   }
+  /**
+   * Checks if a customer has access to a specific feature.
+   * 
+   * This method verifies whether a customer has permission to use a feature
+   * and checks their remaining balance/usage limits. It can be used to gate
+   * features and determine when to show upgrade prompts.
+   * 
+   * @param params - Check parameters including customer ID and feature ID
+   * @returns Promise resolving to access check result with allowed status and balance info
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.check({
+   *   customer_id: "user_123",
+   *   feature_id: "messages",
+   *   required_balance: 1
+   * });
+   * 
+   * if (!result.allowed) {
+   *   console.log("Feature access denied - upgrade required");
+   * }
+   * ```
+   */
   async check(params) {
     return handleCheck({
       instance: this,
       params
     });
   }
+  /**
+   * Tracks usage events for features or analytics.
+   * 
+   * This method records usage events for metered features, updating the customer's
+   * balance and usage statistics. It's typically used server-side to ensure
+   * accurate tracking that cannot be manipulated by users.
+   * 
+   * @param params - Track parameters including customer ID, feature ID, and usage value
+   * @returns Promise resolving to tracking result
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.track({
+   *   customer_id: "user_123",
+   *   feature_id: "messages",
+   *   value: 1 // Track 1 message sent
+   * });
+   * ```
+   */
   async track(params) {
     return handleTrack({
       instance: this,
       params
     });
   }
+  /**
+   * Retrieves usage statistics and analytics for a customer.
+   * 
+   * This method fetches detailed usage information for a customer's features,
+   * including current balances, usage history, and analytics data. Useful
+   * for displaying usage dashboards or generating reports.
+   * 
+   * @param params - Usage parameters including customer ID and optional filters
+   * @returns Promise resolving to usage statistics and analytics data
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.usage({
+   *   customer_id: "user_123",
+   *   feature_id: "messages" 
+   *   value: 20 // Usage value
+   * });
+   * ```
+   */
   async usage(params) {
     return handleUsage({
       instance: this,
       params
     });
   }
+  /**
+   * Performs advanced queries on customer data and analytics.
+   * 
+   * This method allows you to run complex queries against customer data,
+   * usage patterns, and billing information. Useful for generating reports,
+   * analytics, and custom data insights.
+   * 
+   * @param params - Query parameters including customer ID and query specifications
+   * @returns Promise resolving to query results with requested data
+   * 
+   * @example
+   * ```typescript
+   * const result = await autumn.query({
+   *   customer_id: "user_123",
+   *   feature_id: "messages" // feature id to fetch for query, can also be an array
+   * });
+   * 
+   * ```
+   */
   async query(params) {
     return handleQuery({
       instance: this,
@@ -486,8 +654,8 @@ __publicField(Autumn, "entities", entityMethods());
 __publicField(Autumn, "referrals", referralMethods());
 __publicField(Autumn, "features", featureMethods());
 __publicField(Autumn, "checkout", (params) => staticWrapper(handleCheckout, void 0, { params }));
-__publicField(Autumn, "attach", (params) => staticWrapper(handleAttach, void 0, { params }));
 __publicField(Autumn, "usage", (params) => staticWrapper(handleUsage, void 0, { params }));
+__publicField(Autumn, "attach", (params) => staticWrapper(handleAttach, void 0, { params }));
 __publicField(Autumn, "setupPayment", (params) => staticWrapper(handleSetupPayment, void 0, { params }));
 __publicField(Autumn, "cancel", (params) => staticWrapper(handleCancel, void 0, { params }));
 __publicField(Autumn, "check", (params) => staticWrapper(handleCheck, void 0, { params }));
@@ -729,6 +897,8 @@ var CheckoutParamsSchema = z.object({
   product_id: z.string(),
   entity_id: z.string().optional(),
   options: z.array(AttachFeatureOptionsSchema).optional(),
+  force_checkout: z.boolean().optional(),
+  invoice: z.boolean().optional(),
   success_url: z.string().optional(),
   customer_data: CustomerDataSchema.optional(),
   entity_data: z.any().optional(),