license_manager 0.1.0 → 0.2.0

data/docs/PolicySettings.md

@@ -8,6 +8,7 @@
 | **max_machines** | **Integer** | Maximum number of active machines of the licenses created with this policy, copied to each of them. `null` for no limit. Defaults to `null`. | [optional] |
 | **max_offline_duration_seconds** | **Integer** | Longest the applications can run offline with the licenses created with this policy, in seconds, copied to each of them. At least one hour (`3600`). Defaults to one week. | [optional] |
 | **max_version** | [**PolicySettingsMaxVersion**](PolicySettingsMaxVersion.md) |  | [optional] |
+| **money_back_guarantee_days** | **Integer** | Number of days after their creation during which customers can cancel the licenses created with this policy, from the customer portal or with `cancelLicense`, which refunds their Stripe payment. Each license keeps the end of its own period as `cancellableUntil`. `null` for no money back guarantee. Defaults to `null`. | [optional] |
 
 ## Example
 
@@ -18,7 +19,8 @@ instance = LicenseManager::PolicySettings.new(
   duration: null,
   max_machines: 3,
   max_offline_duration_seconds: 604800,
-  max_version: null
+  max_version: null,
+  money_back_guarantee_days: 30
 )
 ```
 

data/docs/PortalApi.md

@@ -16,7 +16,7 @@ All URIs are relative to *https://api.licensemanager.dev*
 
 Create a link to the customer portal
 
-Link letting the customer see their licenses and deactivate their machines in the customer portal, without signing in. Anyone with the link can, until it expires or the customer is deleted: it can't be revoked otherwise. The token also works with the API endpoints that accept customer tokens.  Links can be created while the product's customer portal is disabled, but the portal answers `404` until it's enabled, and `sendPortalLink` refuses to email them.  **Required role permission**: `portalLink:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
+Link letting the customer see their licenses, cancel them during their money back guarantee, and deactivate their machines in the customer portal, without signing in. Anyone with the link can, until it expires or the customer is deleted: it can't be revoked otherwise. The token also works with the API endpoints that accept customer tokens.  Links can be created while the product's customer portal is disabled, but the portal answers `404` until it's enabled, and `sendPortalLink` refuses to email them.  **Required role permission**: `portalLink:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
 
 ### Examples
 

data/docs/PortalLink.md

@@ -5,7 +5,7 @@
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
 | **url** | **String** | Link to the customer portal, holding the token. |  |
-| **token** | **String** | Customer token in the link, with the `customer:read`, `license:read` and `machine:write` permissions. |  |
+| **token** | **String** | Customer token in the link, with the `customer:read`, `license:read`, `license:cancel` and `machine:write` permissions. |  |
 | **expires_at** | **Time** | When the link stops working. |  |
 
 ## Example
@@ -14,7 +14,7 @@
 require 'license_manager'
 
 instance = LicenseManager::PortalLink.new(
-  url: https://app.example.com/portal/x7Kp2QaZ?token=eyJhbGciOi…,
+  url: https://app.licensemanager.dev/portal/x7Kp2QaZ?token=eyJhbGciOi…,
   token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9…,
   expires_at: 2026-01-22T09:30:00.000Z
 )

data/docs/Product.md

@@ -10,6 +10,7 @@
 | **is_test_from_product_id** | **String** | For test products, id of the live product they're a sandbox of. `null` for live products. |  |
 | **logo_url** | **String** | Public URL of the product's logo, shown in the web app and the customer portal. `null` without a logo. |  |
 | **portal** | [**PortalSettings**](PortalSettings.md) |  |  |
+| **auto_machine_change** | **Boolean** | Whether a new machine validating a license already on its max machines takes the place of the license's machine validated the longest ago, rather than being refused with `machine_limit_reached`. When the replaced machine is validated again, it takes its place back and the machine that replaced it is locked. See `validateKey`. |  |
 | **created_at** | **Time** |  |  |
 | **updated_at** | **Time** |  |  |
 
@@ -25,6 +26,7 @@ instance = LicenseManager::Product.new(
   is_test_from_product_id: null,
   logo_url: https://cdn.example.com/logos/x7Kp2QaZ/k3f9a2LpQ7xw.webp,
   portal: null,
+  auto_machine_change: true,
   created_at: 2026-01-15T09:30:00.000Z,
   updated_at: 2026-01-15T09:30:00.000Z
 )

data/docs/ProductStats.md

@@ -5,13 +5,13 @@
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
 | **license_count** | **Integer** | Number of licenses of the product. |  |
-| **active_license_count** | **Integer** | Number of licenses that haven't expired, and that a machine validated in the last 90 days. |  |
+| **active_license_count** | **Integer** | Number of licenses that haven't expired nor were canceled, and that a machine validated in the last 90 days. |  |
 | **new_license_count** | **Integer** | Number of licenses created in the last 30 days, today included, in UTC. |  |
-| **expiring_license_count** | **Integer** | Number of licenses expiring in the next 30 days. |  |
-| **expired_license_count** | **Integer** | Number of licenses that expired in the last 30 days. |  |
+| **expiring_license_count** | **Integer** | Number of licenses expiring in the next 30 days, canceled ones left out. |  |
+| **expired_license_count** | **Integer** | Number of licenses that expired in the last 30 days, canceled ones left out. |  |
 | **active_machine_count** | **Integer** | Number of active machines of the licenses of the product. |  |
 | **in_use_license_count** | **Integer** | Number of licenses with at least one active machine. |  |
-| **seat_count** | **Integer** | Sum of the maximum numbers of machines of the licenses that haven't expired. Licenses without a maximum are left out. |  |
+| **seat_count** | **Integer** | Sum of the maximum numbers of machines of the licenses that haven't expired nor were canceled. Licenses without a maximum are left out. |  |
 | **used_seat_count** | **Integer** | Number of active machines of the licenses counted in `seatCount`, at most their maximum number of machines each. |  |
 | **full_license_count** | **Integer** | Number of licenses counted in `seatCount` active on their maximum number of machines. |  |
 | **days** | **Array<Date>** | The 30 days covered by the daily stats, from the oldest one, in UTC. |  |
@@ -19,6 +19,7 @@
 | **new_licenses_by_day** | **Array<Integer>** | Number of licenses created each day, aligned on `days`. |  |
 | **new_licenses_by_month** | **Array<Integer>** | Number of licenses created each month, aligned on `months`. |  |
 | **new_licenses_by_policy** | [**Array<ProductStatsNewLicensesByPolicyInner>**](ProductStatsNewLicensesByPolicyInner.md) | Number of licenses of each policy created each day and each month, for the policies with licenses created over the covered months. |  |
+| **cancellation** | [**CancellationStats**](CancellationStats.md) | Cancellations of the licenses with a money back guarantee. `null` when no license of the product has one. |  |
 | **revenue** | [**Array<Revenue>**](Revenue.md) | Revenue in each currency licenses were sold in, from the one with the most licenses sold. Amounts aren't converted between currencies. |  |
 | **activations_by_version** | [**Array<ProductStatsActivationsByVersionInner>**](ProductStatsActivationsByVersionInner.md) | Successful activations of the licenses of the product each day, per version of the application, from the most recent one. |  |
 | **active_machines_by_version** | [**Array<ProductStatsActiveMachinesByVersionInner>**](ProductStatsActiveMachinesByVersionInner.md) | Number of active machines running each version of the application, from the most recent one. |  |
@@ -45,6 +46,7 @@ instance = LicenseManager::ProductStats.new(
   new_licenses_by_day: [0, 2, 1],
   new_licenses_by_month: [4, 9, 12],
   new_licenses_by_policy: null,
+  cancellation: null,
   revenue: null,
   activations_by_version: null,
   active_machines_by_version: null,

data/docs/ProductsApi.md

@@ -21,7 +21,7 @@ All URIs are relative to *https://api.licensemanager.dev*
 
 Create a product
 
-Without a `slug`, the product gets one derived from its name: lower cased, without accents and special characters (`Élan Pro 2!` becomes `elan-pro-2`). When another product of the organization already uses it, a dash and 3 random lowercase letters or digits are appended (`elan-pro-2-k3f`), until the slug is free.  An explicit `slug` is used as is: the request fails with a `409` when it's taken, it's never changed.  Slug uniqueness is enforced by the database, so when concurrent requests end up with the same slug, only one succeeds and the others get a `409`, even without an explicit `slug`. Retrying such a request without a `slug` derives a new one.  The product is created with its default policy, named `Default policy` with the `default` slug, whose settings are given by `defaultPolicy`. Omitted settings default to licenses that never expire, on a single machine, offline for one week, for every version of the product. Unlike `createPolicy`, where `maxMachines` defaults to no limit.  With `isTestFromProductId`, the product is a test product: its id, its slug, and the ids, slugs and license keys of its resources start with `test_` (`TEST-` for license keys), and only test API keys reach it. It starts with copies of the policies, releases and portal settings of the live product, `defaultPolicy` is ignored. Later changes to the live product aren't copied: reset the test product to copy them again. Test API keys can only create test products, live API keys only live ones.  **Required role permission**: `product:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
+Without a `slug`, the product gets one derived from its name: lower cased, without accents and special characters (`Élan Pro 2!` becomes `elan-pro-2`). When another product of the organization already uses it, a dash and 3 random lowercase letters or digits are appended (`elan-pro-2-k3f`), until the slug is free.  An explicit `slug` is used as is: the request fails with a `409` when it's taken, it's never changed.  Slug uniqueness is enforced by the database, so when concurrent requests end up with the same slug, only one succeeds and the others get a `409`, even without an explicit `slug`. Retrying such a request without a `slug` derives a new one.  The product is created with its default policy, named `Default policy` with the `default` slug, whose settings are given by `defaultPolicy`. Omitted settings default to licenses that never expire, on a single machine, offline for one week, for every version of the product. Unlike `createPolicy`, where `maxMachines` defaults to no limit.  With `isTestFromProductId`, the product is a test product: its id, its slug, and the ids, slugs and license keys of its resources start with `test_` (`TEST-` for license keys), and only test API keys reach it. It starts with copies of the policies, releases, portal settings and `autoMachineChange` of the live product, `defaultPolicy` is ignored. Later changes to the live product aren't copied: reset the test product to copy them again. Test API keys can only create test products, live API keys only live ones.  **Required role permission**: `product:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
 
 ### Examples
 
@@ -454,7 +454,7 @@ end
 
 Reset a test product
 
-Deletes the customers, licenses, machines, policies and releases of the test product, with their events, then copies the policies, releases and portal settings of its live product again. Its id, name and slug are kept, but the copied policies get new ids. The tokens of its customers, licenses and machines stop working.  **Required role permission**: `product:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
+Deletes the customers, licenses, machines, policies and releases of the test product, with their events, then copies the policies, releases, portal settings and `autoMachineChange` of its live product again. Its id, name and slug are kept, but the copied policies get new ids. The tokens of its customers, licenses and machines stop working.  **Required role permission**: `product:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
 
 ### Examples
 

data/docs/Revenue.md

@@ -5,8 +5,10 @@
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
 | **currency** | **String** | ISO 4217 code of the currency of the revenue. |  |
-| **license_count** | **Integer** | Number of licenses sold in the currency, free ones included. |  |
-| **total** | **Float** | Sum of the prices of the licenses sold in the currency, in major units. |  |
+| **license_count** | **Integer** | Number of licenses sold in the currency, free ones included, canceled ones left out. |  |
+| **total** | **Float** | Sum of the prices of the licenses sold in the currency, in major units, canceled ones left out. |  |
+| **canceled_license_count** | **Integer** | Number of canceled licenses sold in the currency. |  |
+| **canceled_total** | **Float** | Sum of the prices of the canceled licenses sold in the currency, in major units: revenue lost to cancellations. |  |
 | **this_month** | **Float** | Revenue of the current month, in UTC. |  |
 | **last_month** | **Float** | Revenue of the previous month, in UTC. |  |
 | **last30_days** | **Float** | Revenue of the last 30 days, today included, in UTC. |  |
@@ -23,6 +25,8 @@ instance = LicenseManager::Revenue.new(
   currency: USD,
   license_count: 42,
   total: 2099.58,
+  canceled_license_count: 2,
+  canceled_total: 99.98,
   this_month: 349.93,
   last_month: 299.94,
   last30_days: 399.92,

data/docs/StripeIntegration.md

@@ -6,7 +6,7 @@
 | ---- | ---- | ----------- | ----- |
 | **livemode** | **Boolean** | Mode of the Stripe connection the product uses: live for live products, test for test products. |  |
 | **webhook_url_reachable** | **Boolean** | Whether Stripe can reach the API's webhook URL. A local URL can't be: set `WEBHOOK_URL` on the server, like to a tunnel in development. |  |
-| **required_permissions** | [**Array<StripePermission>**](StripePermission.md) | Permissions the restricted API key needs, and why. Every other permission can stay `None`. |  |
+| **required_permissions** | [**Array<StripePermission>**](StripePermission.md) | Permissions the restricted API key needs, and why, the `optional` ones included. Every other permission can stay `None`. |  |
 | **integration** | [**Integration**](Integration.md) | The organization's Stripe connection in this mode, `null` when there's none. |  |
 | **mappings** | [**Array<IntegrationMapping>**](IntegrationMapping.md) | Stripe prices creating licenses of the product. |  |
 

data/docs/StripePermission.md

@@ -7,6 +7,7 @@
 | **resource** | **String** |  |  |
 | **access** | **String** |  |  |
 | **reason** | **String** |  |  |
+| **optional** | **Boolean** | Whether the key can connect without it, losing what it's for, explained by `reason`. |  |
 
 ## Example
 
@@ -16,7 +17,8 @@ require 'license_manager'
 instance = LicenseManager::StripePermission.new(
   resource: Prices,
   access: null,
-  reason: Lists your prices so you can choose which ones create licenses, and checks they can still be paid.
+  reason: Lists your prices so you can choose which ones create licenses, and checks they can still be paid.,
+  optional: false
 )
 ```
 

data/docs/UpdateIntegration.md

@@ -0,0 +1,18 @@
+# LicenseManager::UpdateIntegration
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **auto_refund** | **Boolean** | Whether canceling a license bought through Stripe refunds its payment. Can only be turned on when the integration's `canRefund` is true: the API key has the Refunds: Write permission. | [optional] |
+
+## Example
+
+```ruby
+require 'license_manager'
+
+instance = LicenseManager::UpdateIntegration.new(
+  auto_refund: false
+)
+```
+

data/docs/UpdateLicense.md

@@ -10,6 +10,7 @@
 | **max_offline_duration_seconds** | **Integer** | Longest the applications can run offline with the license, in seconds. At least one hour (`3600`). | [optional] |
 | **max_version** | [**LicenseMaxVersionInput**](LicenseMaxVersionInput.md) | Latest version of the product the license can use. The values left out are kept. | [optional] |
 | **price** | [**PriceInput**](PriceInput.md) |  | [optional] |
+| **cancellable_until** | **Time** | End of the money back guarantee: until then, the customer can cancel the license from the customer portal, or with a token. `null` to not let them. | [optional] |
 
 ## Example
 
@@ -22,7 +23,8 @@ instance = LicenseManager::UpdateLicense.new(
   max_machines: 3,
   max_offline_duration_seconds: 604800,
   max_version: null,
-  price: null
+  price: null,
+  cancellable_until: 2026-02-14T09:30:00.000Z
 )
 ```
 

data/docs/UpdatePolicy.md

@@ -11,6 +11,7 @@
 | **max_machines** | **Integer** | Maximum number of active machines of the licenses created with this policy, copied to each of them. `null` for no limit. Defaults to `null`. | [optional] |
 | **max_offline_duration_seconds** | **Integer** | Longest the applications can run offline with the licenses created with this policy, in seconds, copied to each of them. At least one hour (`3600`). Defaults to one week. | [optional] |
 | **max_version** | [**PolicySettingsMaxVersion**](PolicySettingsMaxVersion.md) |  | [optional] |
+| **money_back_guarantee_days** | **Integer** | Number of days after their creation during which customers can cancel the licenses created with this policy, from the customer portal or with `cancelLicense`, which refunds their Stripe payment. Each license keeps the end of its own period as `cancellableUntil`. `null` for no money back guarantee. Defaults to `null`. | [optional] |
 
 ## Example
 
@@ -24,7 +25,8 @@ instance = LicenseManager::UpdatePolicy.new(
   duration: null,
   max_machines: 3,
   max_offline_duration_seconds: 604800,
-  max_version: null
+  max_version: null,
+  money_back_guarantee_days: 30
 )
 ```
 

data/docs/UpdateProduct.md

@@ -7,6 +7,7 @@
 | **name** | **String** |  | [optional] |
 | **slug** | **String** | Unique within the organization. Defaults to the name, lower cased, without accents and special characters. Starts with `test_` in test products, which is added when missing, and removed in live products. | [optional] |
 | **portal** | [**UpdateProductPortal**](UpdateProductPortal.md) |  | [optional] |
+| **auto_machine_change** | **Boolean** | Whether a new machine validating a license already on its max machines takes the place of the license's machine validated the longest ago, rather than being refused with `machine_limit_reached`. When the replaced machine is validated again, it takes its place back and the machine that replaced it is locked. See `validateKey`. | [optional] |
 
 ## Example
 
@@ -16,7 +17,8 @@ require 'license_manager'
 instance = LicenseManager::UpdateProduct.new(
   name: Acme Pro,
   slug: acme-pro,
-  portal: null
+  portal: null,
+  auto_machine_change: true
 )
 ```
 

data/lib/license_manager/api/integrations_api.rb

@@ -482,6 +482,80 @@ module LicenseManager
       return data, status_code, headers
     end
 
+    # Update an integration
+    # Changes the settings of the integration, for every product of its mode. Doesn't accept tokens: only API keys and sessions.  **Required role permission**: `integration:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # @param id [String] 
+    # @param update_integration [UpdateIntegration] 
+    # @param [Hash] opts the optional parameters
+    # @return [Integration]
+    def update_integration(id, update_integration, opts = {})
+      data, _status_code, _headers = update_integration_with_http_info(id, update_integration, opts)
+      data
+    end
+
+    # Update an integration
+    # Changes the settings of the integration, for every product of its mode. Doesn't accept tokens: only API keys and sessions.  **Required role permission**: `integration:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # @param id [String] 
+    # @param update_integration [UpdateIntegration] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Integration, Integer, Hash)>] Integration data, response status code and response headers
+    def update_integration_with_http_info(id, update_integration, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: IntegrationsApi.update_integration ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling IntegrationsApi.update_integration"
+      end
+      # verify the required parameter 'update_integration' is set
+      if @api_client.config.client_side_validation && update_integration.nil?
+        fail ArgumentError, "Missing the required parameter 'update_integration' when calling IntegrationsApi.update_integration"
+      end
+      # resource path
+      local_var_path = '/v1/integrations/{id}'.sub('{id}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(update_integration)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'Integration'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['apiKey']
+
+      new_options = opts.merge(
+        :operation => :"IntegrationsApi.update_integration",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: IntegrationsApi#update_integration\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # Change the policy of a mapping
     # Only affects the licenses created afterwards. Doesn't accept tokens: only API keys and sessions.  **Required role permission**: `integration:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param id [String] 

data/lib/license_manager/api/licenses_api.rb

@@ -19,8 +19,82 @@ module LicenseManager
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     end
+    # Cancel a license
+    # Cancels the license right away: validating its key then fails with `license_expired`, like an expired license, and its status is `canceled`. A cancellation can't be undone.  Customers can cancel their licenses until their `cancellableUntil`, the end of their money back guarantee: tokens can't cancel a license past it, or without one. API keys and sessions can cancel any license.  When the license was bought through the Stripe integration, its payment is refunded in the background, unless the integration disables `autoRefund`, its API key lacks the optional Refunds: Write permission (`canRefund`), or `refund` is `false`: the refund is its price paid, taxes included, and its id is set as `stripeRefundId`. The customer is emailed a confirmation, and the owners and admins of the organization are told about the cancellation and its refund. In test products, the customer is only emailed when their email is a member's of the organization.  Records a `license.canceled` event, then a `license.refunded` or `license.refund_failed` one once the refund is done.  **Token access**: customer, license tokens with the `license:cancel` permission (or the matching write one). A token reaches the license it's scoped to, or the licenses of its customer.  **Required role permission**: `license:cancel` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # @param id [String] 
+    # @param cancel_license [CancelLicense] 
+    # @param [Hash] opts the optional parameters
+    # @return [License]
+    def cancel_license(id, cancel_license, opts = {})
+      data, _status_code, _headers = cancel_license_with_http_info(id, cancel_license, opts)
+      data
+    end
+
+    # Cancel a license
+    # Cancels the license right away: validating its key then fails with `license_expired`, like an expired license, and its status is `canceled`. A cancellation can't be undone.  Customers can cancel their licenses until their `cancellableUntil`, the end of their money back guarantee: tokens can't cancel a license past it, or without one. API keys and sessions can cancel any license.  When the license was bought through the Stripe integration, its payment is refunded in the background, unless the integration disables `autoRefund`, its API key lacks the optional Refunds: Write permission (`canRefund`), or `refund` is `false`: the refund is its price paid, taxes included, and its id is set as `stripeRefundId`. The customer is emailed a confirmation, and the owners and admins of the organization are told about the cancellation and its refund. In test products, the customer is only emailed when their email is a member's of the organization.  Records a `license.canceled` event, then a `license.refunded` or `license.refund_failed` one once the refund is done.  **Token access**: customer, license tokens with the `license:cancel` permission (or the matching write one). A token reaches the license it's scoped to, or the licenses of its customer.  **Required role permission**: `license:cancel` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # @param id [String] 
+    # @param cancel_license [CancelLicense] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(License, Integer, Hash)>] License data, response status code and response headers
+    def cancel_license_with_http_info(id, cancel_license, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: LicensesApi.cancel_license ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling LicensesApi.cancel_license"
+      end
+      # verify the required parameter 'cancel_license' is set
+      if @api_client.config.client_side_validation && cancel_license.nil?
+        fail ArgumentError, "Missing the required parameter 'cancel_license' when calling LicensesApi.cancel_license"
+      end
+      # resource path
+      local_var_path = '/v1/licenses/{id}/cancel'.sub('{id}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(cancel_license)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'License'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['apiKey', 'token']
+
+      new_options = opts.merge(
+        :operation => :"LicensesApi.cancel_license",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: LicensesApi#cancel_license\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # Create a license
-    # Without a `key`, the license gets a random one, like `7KQ2M-X9ZPA-H4TRC-WN6EY-B3JDF`: 5 groups of 5 characters separated by dashes, each character an upper case letter or a digit other than `O`, `0`, `I` and `1`. That's 32 possible characters encoding 5 bits each, for 125 random bits.  Without a `policyId`, the license follows the product's default policy.  Without an `expiresAt`, the license expires after the duration of its policy, or never when the policy has none. `expiresAt: null` makes it never expire.  Without a `price`, the price paid for the license is unknown: it's left out of the revenue stats.  The values of `maxVersion` left out are taken from the max version of the policy: its hard-coded version, or the times after the creation of the license its versions lock.  The license belongs to the product's customer with the given `email`, which is created when there's none.  With `sendKey: true`, the key is emailed to the customer once the license is created.  The license copies the settings of its policy when it's created: later changes to the policy don't affect it. Its key, policy and customer can't be changed afterwards.  **Required role permission**: `license:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # Without a `key`, the license gets a random one, like `7KQ2M-X9ZPA-H4TRC-WN6EY-B3JDF`: 5 groups of 5 characters separated by dashes, each character an upper case letter or a digit other than `O`, `0`, `I` and `1`. That's 32 possible characters encoding 5 bits each, for 125 random bits.  Without a `policyId`, the license follows the product's default policy.  Without an `expiresAt`, the license expires after the duration of its policy, or never when the policy has none. `expiresAt: null` makes it never expire.  Without a `price`, the price paid for the license is unknown: it's left out of the revenue stats.  Without a `cancellableUntil`, the customer can cancel the license during the policy's `moneyBackGuaranteeDays` after its creation, or never when the policy has none.  The values of `maxVersion` left out are taken from the max version of the policy: its hard-coded version, or the times after the creation of the license its versions lock.  The license belongs to the product's customer with the given `email`, which is created when there's none.  With `sendKey: true`, the key is emailed to the customer once the license is created.  The license copies the settings of its policy when it's created: later changes to the policy don't affect it. Its key, policy and customer can't be changed afterwards.  **Required role permission**: `license:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param product_id [String] 
     # @param create_license [CreateLicense] 
     # @param [Hash] opts the optional parameters
@@ -31,7 +105,7 @@ module LicenseManager
     end
 
     # Create a license
-    # Without a &#x60;key&#x60;, the license gets a random one, like &#x60;7KQ2M-X9ZPA-H4TRC-WN6EY-B3JDF&#x60;: 5 groups of 5 characters separated by dashes, each character an upper case letter or a digit other than &#x60;O&#x60;, &#x60;0&#x60;, &#x60;I&#x60; and &#x60;1&#x60;. That&#39;s 32 possible characters encoding 5 bits each, for 125 random bits.  Without a &#x60;policyId&#x60;, the license follows the product&#39;s default policy.  Without an &#x60;expiresAt&#x60;, the license expires after the duration of its policy, or never when the policy has none. &#x60;expiresAt: null&#x60; makes it never expire.  Without a &#x60;price&#x60;, the price paid for the license is unknown: it&#39;s left out of the revenue stats.  The values of &#x60;maxVersion&#x60; left out are taken from the max version of the policy: its hard-coded version, or the times after the creation of the license its versions lock.  The license belongs to the product&#39;s customer with the given &#x60;email&#x60;, which is created when there&#39;s none.  With &#x60;sendKey: true&#x60;, the key is emailed to the customer once the license is created.  The license copies the settings of its policy when it&#39;s created: later changes to the policy don&#39;t affect it. Its key, policy and customer can&#39;t be changed afterwards.  **Required role permission**: &#x60;license:create&#x60; when called with a session, granted by the member&#39;s role. API keys aren&#39;t limited by roles.
+    # Without a &#x60;key&#x60;, the license gets a random one, like &#x60;7KQ2M-X9ZPA-H4TRC-WN6EY-B3JDF&#x60;: 5 groups of 5 characters separated by dashes, each character an upper case letter or a digit other than &#x60;O&#x60;, &#x60;0&#x60;, &#x60;I&#x60; and &#x60;1&#x60;. That&#39;s 32 possible characters encoding 5 bits each, for 125 random bits.  Without a &#x60;policyId&#x60;, the license follows the product&#39;s default policy.  Without an &#x60;expiresAt&#x60;, the license expires after the duration of its policy, or never when the policy has none. &#x60;expiresAt: null&#x60; makes it never expire.  Without a &#x60;price&#x60;, the price paid for the license is unknown: it&#39;s left out of the revenue stats.  Without a &#x60;cancellableUntil&#x60;, the customer can cancel the license during the policy&#39;s &#x60;moneyBackGuaranteeDays&#x60; after its creation, or never when the policy has none.  The values of &#x60;maxVersion&#x60; left out are taken from the max version of the policy: its hard-coded version, or the times after the creation of the license its versions lock.  The license belongs to the product&#39;s customer with the given &#x60;email&#x60;, which is created when there&#39;s none.  With &#x60;sendKey: true&#x60;, the key is emailed to the customer once the license is created.  The license copies the settings of its policy when it&#39;s created: later changes to the policy don&#39;t affect it. Its key, policy and customer can&#39;t be changed afterwards.  **Required role permission**: &#x60;license:create&#x60; when called with a session, granted by the member&#39;s role. API keys aren&#39;t limited by roles.
     # @param product_id [String] 
     # @param create_license [CreateLicense] 
     # @param [Hash] opts the optional parameters
@@ -735,7 +809,7 @@ module LicenseManager
     end
 
     # Update a license
-    # The key, policy and customer of a license can't be changed: sending them does nothing.  The changes apply to the next validations of the key, not to the license tokens `validateKey` already returned, which stay valid until they expire. Lowering `maxMachines` doesn't deactivate machines: the ones already active keep validating, and new ones are refused until enough are deactivated.  **Required role permission**: `license:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # The key, policy and customer of a license can't be changed: sending them does nothing.  The changes apply to the next validations of the key, not to the license tokens `validateKey` already returned, which stay valid until they expire. Lowering `maxMachines` doesn't deactivate machines: the ones already active keep validating, and new ones replace them one at a time when the product has `autoMachineChange`, or are refused until enough are deactivated.  **Required role permission**: `license:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param id [String] 
     # @param update_license [UpdateLicense] 
     # @param [Hash] opts the optional parameters
@@ -746,7 +820,7 @@ module LicenseManager
     end
 
     # Update a license
-    # The key, policy and customer of a license can&#39;t be changed: sending them does nothing.  The changes apply to the next validations of the key, not to the license tokens &#x60;validateKey&#x60; already returned, which stay valid until they expire. Lowering &#x60;maxMachines&#x60; doesn&#39;t deactivate machines: the ones already active keep validating, and new ones are refused until enough are deactivated.  **Required role permission**: &#x60;license:update&#x60; when called with a session, granted by the member&#39;s role. API keys aren&#39;t limited by roles.
+    # The key, policy and customer of a license can&#39;t be changed: sending them does nothing.  The changes apply to the next validations of the key, not to the license tokens &#x60;validateKey&#x60; already returned, which stay valid until they expire. Lowering &#x60;maxMachines&#x60; doesn&#39;t deactivate machines: the ones already active keep validating, and new ones replace them one at a time when the product has &#x60;autoMachineChange&#x60;, or are refused until enough are deactivated.  **Required role permission**: &#x60;license:update&#x60; when called with a session, granted by the member&#39;s role. API keys aren&#39;t limited by roles.
     # @param id [String] 
     # @param update_license [UpdateLicense] 
     # @param [Hash] opts the optional parameters
@@ -809,7 +883,7 @@ module LicenseManager
     end
 
     # Validate a license key
-    # Checks the license key of the product on a machine and returns a token the application can verify offline with the organization's public key. Doesn't need authentication.  The license must allow the `version`: up to its `maxVersion.version` when it has one, like `\"2.3\"` for every 2.3.z version and older. Its `maxVersion.lockMajorAt` and `maxVersion.lockMinorAt` are enforced once they hard-code `maxVersion.version`, within the hour they're reached. When it doesn't, the error's `latestAllowedVersion` is the latest release of the product the license allows, so the application can offer to install it.  The machine with the `fingerprint` is created when the license has none, and activated when it's deactivated, unless the license is already active on its maximum number of machines. A machine that's already active is never refused for the maximum number of machines, even when it was lowered below the number of active machines. Its `version`, and its `name` and `platform` when given, are updated: they can't be cleared.  The checks run in this order, and the first one failing answers: the license has expired, then it doesn't allow the version, then it's on its maximum number of machines. Each failure is recorded as a `license.validation_failed` event, except for keys that don't exist.  Changes to the license, like deactivating the machine or shortening its expiration, don't revoke the tokens already returned: the application only sees them when it validates its key again, at the latest when its token expires.
+    # Checks the license key of the product on a machine and returns a token the application can verify offline with the organization's public key. Doesn't need authentication.  The license must allow the `version`: up to its `maxVersion.version` when it has one, like `\"2.3\"` for every 2.3.z version and older. Its `maxVersion.lockMajorAt` and `maxVersion.lockMinorAt` are enforced once they hard-code `maxVersion.version`, within the hour they're reached. When it doesn't, the error's `latestAllowedVersion` is the latest release of the product the license allows, so the application can offer to install it.  The machine with the `fingerprint` is created when the license has none, and activated when it's deactivated, unless the license is already active on its maximum number of machines. A machine that's already active is never refused for the maximum number of machines, even when it was lowered below the number of active machines. Its `version`, and its `name` and `platform` when given, are updated: they can't be cleared.  Unless the product disables `autoMachineChange`, a new machine isn't refused when the license is on its maximum number of machines: it takes the place of the active machine validated the longest ago, which is deactivated with its `overriddenByMachineId` set to the new machine, and recorded as a `machine.deactivated` event. When a machine deactivated this way is validated again, it takes its place back: the machine that overrode it, and the ones that overrode that one in turn, are locked, with their `overriddenByMachineId` set to the machine coming back. A locked machine is always refused, so two machines can't take turns on one place.  The checks run in this order, and the first one failing answers: the license has expired or was canceled, then it doesn't allow the version, then the machine is locked, then it's on its maximum number of machines. Each failure is recorded as a `license.validation_failed` event, except for keys that don't exist.  Changes to the license, like deactivating the machine or shortening its expiration, don't revoke the tokens already returned: the application only sees them when it validates its key again, at the latest when its token expires.
     # @param product_id [String] 
     # @param validate_key [ValidateKey] 
     # @param [Hash] opts the optional parameters
@@ -820,7 +894,7 @@ module LicenseManager
     end
 
     # Validate a license key
-    # Checks the license key of the product on a machine and returns a token the application can verify offline with the organization&#39;s public key. Doesn&#39;t need authentication.  The license must allow the &#x60;version&#x60;: up to its &#x60;maxVersion.version&#x60; when it has one, like &#x60;\&quot;2.3\&quot;&#x60; for every 2.3.z version and older. Its &#x60;maxVersion.lockMajorAt&#x60; and &#x60;maxVersion.lockMinorAt&#x60; are enforced once they hard-code &#x60;maxVersion.version&#x60;, within the hour they&#39;re reached. When it doesn&#39;t, the error&#39;s &#x60;latestAllowedVersion&#x60; is the latest release of the product the license allows, so the application can offer to install it.  The machine with the &#x60;fingerprint&#x60; is created when the license has none, and activated when it&#39;s deactivated, unless the license is already active on its maximum number of machines. A machine that&#39;s already active is never refused for the maximum number of machines, even when it was lowered below the number of active machines. Its &#x60;version&#x60;, and its &#x60;name&#x60; and &#x60;platform&#x60; when given, are updated: they can&#39;t be cleared.  The checks run in this order, and the first one failing answers: the license has expired, then it doesn&#39;t allow the version, then it&#39;s on its maximum number of machines. Each failure is recorded as a &#x60;license.validation_failed&#x60; event, except for keys that don&#39;t exist.  Changes to the license, like deactivating the machine or shortening its expiration, don&#39;t revoke the tokens already returned: the application only sees them when it validates its key again, at the latest when its token expires.
+    # Checks the license key of the product on a machine and returns a token the application can verify offline with the organization&#39;s public key. Doesn&#39;t need authentication.  The license must allow the &#x60;version&#x60;: up to its &#x60;maxVersion.version&#x60; when it has one, like &#x60;\&quot;2.3\&quot;&#x60; for every 2.3.z version and older. Its &#x60;maxVersion.lockMajorAt&#x60; and &#x60;maxVersion.lockMinorAt&#x60; are enforced once they hard-code &#x60;maxVersion.version&#x60;, within the hour they&#39;re reached. When it doesn&#39;t, the error&#39;s &#x60;latestAllowedVersion&#x60; is the latest release of the product the license allows, so the application can offer to install it.  The machine with the &#x60;fingerprint&#x60; is created when the license has none, and activated when it&#39;s deactivated, unless the license is already active on its maximum number of machines. A machine that&#39;s already active is never refused for the maximum number of machines, even when it was lowered below the number of active machines. Its &#x60;version&#x60;, and its &#x60;name&#x60; and &#x60;platform&#x60; when given, are updated: they can&#39;t be cleared.  Unless the product disables &#x60;autoMachineChange&#x60;, a new machine isn&#39;t refused when the license is on its maximum number of machines: it takes the place of the active machine validated the longest ago, which is deactivated with its &#x60;overriddenByMachineId&#x60; set to the new machine, and recorded as a &#x60;machine.deactivated&#x60; event. When a machine deactivated this way is validated again, it takes its place back: the machine that overrode it, and the ones that overrode that one in turn, are locked, with their &#x60;overriddenByMachineId&#x60; set to the machine coming back. A locked machine is always refused, so two machines can&#39;t take turns on one place.  The checks run in this order, and the first one failing answers: the license has expired or was canceled, then it doesn&#39;t allow the version, then the machine is locked, then it&#39;s on its maximum number of machines. Each failure is recorded as a &#x60;license.validation_failed&#x60; event, except for keys that don&#39;t exist.  Changes to the license, like deactivating the machine or shortening its expiration, don&#39;t revoke the tokens already returned: the application only sees them when it validates its key again, at the latest when its token expires.
     # @param product_id [String] 
     # @param validate_key [ValidateKey] 
     # @param [Hash] opts the optional parameters

data/lib/license_manager/api/machines_api.rb

@@ -20,7 +20,7 @@ module LicenseManager
       @api_client = api_client
     end
     # Deactivate a machine
-    # The machine no longer counts as using the license, freeing its place when the license has a maximum number of machines. Validating the license key on the machine activates it again, unless the license is on its maximum number of machines by then. Deactivating a deactivated machine does nothing.  The license token `validateKey` returned to the machine isn't revoked: the application can keep running offline until it expires. Machines can't be deleted: they're deleted with their license.  **Token access**: customer, license, machine tokens with the `machine:write` permission (or the matching write one). A token reaches the machine it's scoped to, or the machines of its license or customer.  **Required role permission**: `machine:deactivate` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # The machine no longer counts as using the license, freeing its place when the license has a maximum number of machines. Validating the license key on the machine activates it again, unless the license is on its maximum number of machines by then. Deactivating a deactivated or locked machine does nothing.  The license token `validateKey` returned to the machine isn't revoked: the application can keep running offline until it expires. Machines can't be deleted: they're deleted with their license.  **Token access**: customer, license, machine tokens with the `machine:write` permission (or the matching write one). A token reaches the machine it's scoped to, or the machines of its license or customer.  **Required role permission**: `machine:deactivate` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param id [String] 
     # @param [Hash] opts the optional parameters
     # @return [Machine]
@@ -30,7 +30,7 @@ module LicenseManager
     end
 
     # Deactivate a machine
-    # The machine no longer counts as using the license, freeing its place when the license has a maximum number of machines. Validating the license key on the machine activates it again, unless the license is on its maximum number of machines by then. Deactivating a deactivated machine does nothing.  The license token `validateKey` returned to the machine isn't revoked: the application can keep running offline until it expires. Machines can't be deleted: they're deleted with their license.  **Token access**: customer, license, machine tokens with the `machine:write` permission (or the matching write one). A token reaches the machine it's scoped to, or the machines of its license or customer.  **Required role permission**: `machine:deactivate` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # The machine no longer counts as using the license, freeing its place when the license has a maximum number of machines. Validating the license key on the machine activates it again, unless the license is on its maximum number of machines by then. Deactivating a deactivated or locked machine does nothing.  The license token `validateKey` returned to the machine isn't revoked: the application can keep running offline until it expires. Machines can't be deleted: they're deleted with their license.  **Token access**: customer, license, machine tokens with the `machine:write` permission (or the matching write one). A token reaches the machine it's scoped to, or the machines of its license or customer.  **Required role permission**: `machine:deactivate` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param id [String] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(Machine, Integer, Hash)>] Machine data, response status code and response headers
@@ -204,7 +204,7 @@ module LicenseManager
         fail ArgumentError, 'invalid value for "opts[:"search"]" when calling MachinesApi.list_machines, the character length must be greater than or equal to 1.'
       end
 
-      allowable_values = ["active", "deactivated", "unknown_default_open_api"]
+      allowable_values = ["active", "deactivated", "locked", "unknown_default_open_api"]
       if @api_client.config.client_side_validation && opts[:'status'] && !allowable_values.include?(opts[:'status'])
         fail ArgumentError, "invalid value for \"status\", must be one of #{allowable_values}"
       end

data/lib/license_manager/api/portal_api.rb

@@ -20,7 +20,7 @@ module LicenseManager
       @api_client = api_client
     end
     # Create a link to the customer portal
-    # Link letting the customer see their licenses and deactivate their machines in the customer portal, without signing in. Anyone with the link can, until it expires or the customer is deleted: it can't be revoked otherwise. The token also works with the API endpoints that accept customer tokens.  Links can be created while the product's customer portal is disabled, but the portal answers `404` until it's enabled, and `sendPortalLink` refuses to email them.  **Required role permission**: `portalLink:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # Link letting the customer see their licenses, cancel them during their money back guarantee, and deactivate their machines in the customer portal, without signing in. Anyone with the link can, until it expires or the customer is deleted: it can't be revoked otherwise. The token also works with the API endpoints that accept customer tokens.  Links can be created while the product's customer portal is disabled, but the portal answers `404` until it's enabled, and `sendPortalLink` refuses to email them.  **Required role permission**: `portalLink:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param id [String] 
     # @param create_portal_link [CreatePortalLink] 
     # @param [Hash] opts the optional parameters
@@ -31,7 +31,7 @@ module LicenseManager
     end
 
     # Create a link to the customer portal
-    # Link letting the customer see their licenses and deactivate their machines in the customer portal, without signing in. Anyone with the link can, until it expires or the customer is deleted: it can't be revoked otherwise. The token also works with the API endpoints that accept customer tokens.  Links can be created while the product's customer portal is disabled, but the portal answers `404` until it's enabled, and `sendPortalLink` refuses to email them.  **Required role permission**: `portalLink:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # Link letting the customer see their licenses, cancel them during their money back guarantee, and deactivate their machines in the customer portal, without signing in. Anyone with the link can, until it expires or the customer is deleted: it can't be revoked otherwise. The token also works with the API endpoints that accept customer tokens.  Links can be created while the product's customer portal is disabled, but the portal answers `404` until it's enabled, and `sendPortalLink` refuses to email them.  **Required role permission**: `portalLink:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param id [String] 
     # @param create_portal_link [CreatePortalLink] 
     # @param [Hash] opts the optional parameters

data/lib/license_manager/api/products_api.rb

@@ -20,7 +20,7 @@ module LicenseManager
       @api_client = api_client
     end
     # Create a product
-    # Without a `slug`, the product gets one derived from its name: lower cased, without accents and special characters (`Élan Pro 2!` becomes `elan-pro-2`). When another product of the organization already uses it, a dash and 3 random lowercase letters or digits are appended (`elan-pro-2-k3f`), until the slug is free.  An explicit `slug` is used as is: the request fails with a `409` when it's taken, it's never changed.  Slug uniqueness is enforced by the database, so when concurrent requests end up with the same slug, only one succeeds and the others get a `409`, even without an explicit `slug`. Retrying such a request without a `slug` derives a new one.  The product is created with its default policy, named `Default policy` with the `default` slug, whose settings are given by `defaultPolicy`. Omitted settings default to licenses that never expire, on a single machine, offline for one week, for every version of the product. Unlike `createPolicy`, where `maxMachines` defaults to no limit.  With `isTestFromProductId`, the product is a test product: its id, its slug, and the ids, slugs and license keys of its resources start with `test_` (`TEST-` for license keys), and only test API keys reach it. It starts with copies of the policies, releases and portal settings of the live product, `defaultPolicy` is ignored. Later changes to the live product aren't copied: reset the test product to copy them again. Test API keys can only create test products, live API keys only live ones.  **Required role permission**: `product:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # Without a `slug`, the product gets one derived from its name: lower cased, without accents and special characters (`Élan Pro 2!` becomes `elan-pro-2`). When another product of the organization already uses it, a dash and 3 random lowercase letters or digits are appended (`elan-pro-2-k3f`), until the slug is free.  An explicit `slug` is used as is: the request fails with a `409` when it's taken, it's never changed.  Slug uniqueness is enforced by the database, so when concurrent requests end up with the same slug, only one succeeds and the others get a `409`, even without an explicit `slug`. Retrying such a request without a `slug` derives a new one.  The product is created with its default policy, named `Default policy` with the `default` slug, whose settings are given by `defaultPolicy`. Omitted settings default to licenses that never expire, on a single machine, offline for one week, for every version of the product. Unlike `createPolicy`, where `maxMachines` defaults to no limit.  With `isTestFromProductId`, the product is a test product: its id, its slug, and the ids, slugs and license keys of its resources start with `test_` (`TEST-` for license keys), and only test API keys reach it. It starts with copies of the policies, releases, portal settings and `autoMachineChange` of the live product, `defaultPolicy` is ignored. Later changes to the live product aren't copied: reset the test product to copy them again. Test API keys can only create test products, live API keys only live ones.  **Required role permission**: `product:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param create_product_with_policy [CreateProductWithPolicy] 
     # @param [Hash] opts the optional parameters
     # @return [Product]
@@ -30,7 +30,7 @@ module LicenseManager
     end
 
     # Create a product
-    # Without a `slug`, the product gets one derived from its name: lower cased, without accents and special characters (`Élan Pro 2!` becomes `elan-pro-2`). When another product of the organization already uses it, a dash and 3 random lowercase letters or digits are appended (`elan-pro-2-k3f`), until the slug is free.  An explicit `slug` is used as is: the request fails with a `409` when it's taken, it's never changed.  Slug uniqueness is enforced by the database, so when concurrent requests end up with the same slug, only one succeeds and the others get a `409`, even without an explicit `slug`. Retrying such a request without a `slug` derives a new one.  The product is created with its default policy, named `Default policy` with the `default` slug, whose settings are given by `defaultPolicy`. Omitted settings default to licenses that never expire, on a single machine, offline for one week, for every version of the product. Unlike `createPolicy`, where `maxMachines` defaults to no limit.  With `isTestFromProductId`, the product is a test product: its id, its slug, and the ids, slugs and license keys of its resources start with `test_` (`TEST-` for license keys), and only test API keys reach it. It starts with copies of the policies, releases and portal settings of the live product, `defaultPolicy` is ignored. Later changes to the live product aren't copied: reset the test product to copy them again. Test API keys can only create test products, live API keys only live ones.  **Required role permission**: `product:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # Without a `slug`, the product gets one derived from its name: lower cased, without accents and special characters (`Élan Pro 2!` becomes `elan-pro-2`). When another product of the organization already uses it, a dash and 3 random lowercase letters or digits are appended (`elan-pro-2-k3f`), until the slug is free.  An explicit `slug` is used as is: the request fails with a `409` when it's taken, it's never changed.  Slug uniqueness is enforced by the database, so when concurrent requests end up with the same slug, only one succeeds and the others get a `409`, even without an explicit `slug`. Retrying such a request without a `slug` derives a new one.  The product is created with its default policy, named `Default policy` with the `default` slug, whose settings are given by `defaultPolicy`. Omitted settings default to licenses that never expire, on a single machine, offline for one week, for every version of the product. Unlike `createPolicy`, where `maxMachines` defaults to no limit.  With `isTestFromProductId`, the product is a test product: its id, its slug, and the ids, slugs and license keys of its resources start with `test_` (`TEST-` for license keys), and only test API keys reach it. It starts with copies of the policies, releases, portal settings and `autoMachineChange` of the live product, `defaultPolicy` is ignored. Later changes to the live product aren't copied: reset the test product to copy them again. Test API keys can only create test products, live API keys only live ones.  **Required role permission**: `product:create` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param create_product_with_policy [CreateProductWithPolicy] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(Product, Integer, Hash)>] Product data, response status code and response headers
@@ -439,7 +439,7 @@ module LicenseManager
     end
 
     # Reset a test product
-    # Deletes the customers, licenses, machines, policies and releases of the test product, with their events, then copies the policies, releases and portal settings of its live product again. Its id, name and slug are kept, but the copied policies get new ids. The tokens of its customers, licenses and machines stop working.  **Required role permission**: `product:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
+    # Deletes the customers, licenses, machines, policies and releases of the test product, with their events, then copies the policies, releases, portal settings and `autoMachineChange` of its live product again. Its id, name and slug are kept, but the copied policies get new ids. The tokens of its customers, licenses and machines stop working.  **Required role permission**: `product:update` when called with a session, granted by the member's role. API keys aren't limited by roles.
     # @param id [String] 
     # @param [Hash] opts the optional parameters
     # @return [Product]
@@ -449,7 +449,7 @@ module LicenseManager
     end
 
     # Reset a test product
-    # Deletes the customers, licenses, machines, policies and releases of the test product, with their events, then copies the policies, releases and portal settings of its live product again. Its id, name and slug are kept, but the copied policies get new ids. The tokens of its customers, licenses and machines stop working.  **Required role permission**: &#x60;product:update&#x60; when called with a session, granted by the member&#39;s role. API keys aren&#39;t limited by roles.
+    # Deletes the customers, licenses, machines, policies and releases of the test product, with their events, then copies the policies, releases, portal settings and &#x60;autoMachineChange&#x60; of its live product again. Its id, name and slug are kept, but the copied policies get new ids. The tokens of its customers, licenses and machines stop working.  **Required role permission**: &#x60;product:update&#x60; when called with a session, granted by the member&#39;s role. API keys aren&#39;t limited by roles.
     # @param id [String] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(Product, Integer, Hash)>] Product data, response status code and response headers