auth0 6.4.0 → 6.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0ee008c469f95695eb60571f4ab79355846375df2cb681eb3bead53350eabdc
-  data.tar.gz: 274ca0c5c3ed5bd0ca1c064304a547b2133b3b8b57e086a8e721fc6db5f4ed4b
+  metadata.gz: 0aef33bb7fb9dd8990a6f3a39622aba986b7a020907d8525990391d9deb71e0f
+  data.tar.gz: c90d04eb8ef0023be41b267547320b64ab259d651ddab120a42be278ee193285
 SHA512:
-  metadata.gz: 3fafaf658bcec42cbd757cba5b05e0f3a511f1065857cb30751e539e0e5b61c004861c337274d8146cb555e7500c16b7307ba6a9ac6d5b732f78af1adad387e9
-  data.tar.gz: 5c2d1b45e193299f235426a4ea46a6fb31082c48faa73e5959bda6f4daefb93ed68f935e1cbdb1f1912067ec50b943e89d65f48432d1eaf7618381fb49e79e43
+  metadata.gz: cc5b3db616d82d0dc6619e51da61abbb3455ceae6eec16869122cbfc88b8626aa66d9c57c6549ff5d9a1659691c8379527078d4e5f747e06f3688fbf28c8391c
+  data.tar.gz: 8d30725488a0cd575d8bc6fff7e740a8f17d8170e6871fade8e83a584e0b3f72b78b0059c83d2ba6e52901a4210bc1d1078f14c7e75baee87f7696e87a413701

data/.fern/metadata.json

@@ -1,5 +1,5 @@
 {
-  "cliVersion": "5.92.1",
+  "cliVersion": "5.144.3",
   "generatorName": "fernapi/fern-ruby-sdk",
   "generatorVersion": "1.24.1",
   "generatorConfig": {
@@ -10,9 +10,9 @@
     "offsetSemantics": "page-index",
     "useDefaultRequestParameterValues": true
   },
-  "originGitCommit": "d0c167e92ed941d977b98e76601bd970b0e5ecea",
+  "originGitCommit": "275ad23d02d33d550693bc23ebae86dfa8ee7101",
   "originGitCommitIsDirty": false,
   "invokedBy": "ci",
   "ciProvider": "github",
-  "sdkVersion": "6.3.1"
+  "sdkVersion": "6.4.1"
 }

data/.fern/replay.lock

@@ -54,5 +54,11 @@ generations:
     cli_version: unknown
     generator_versions:
       fernapi/fern-ruby-sdk: 1.24.1
-current_generation: ddd12c1ca38e6c93db2c1d30e4194a2ecbca03ba
+  - commit_sha: 3ee763815dcd7a7a39f5c3c7c6bd40d4de0014d6
+    tree_hash: 0ce0997d753141426376e5ff1dcc183ea138c84e
+    timestamp: 2026-10-13T10:24:06.305Z
+    cli_version: unknown
+    generator_versions:
+      fernapi/fern-ruby-sdk: 1.24.1
+current_generation: 3ee763815dcd7a7a39f5c3c7c6bd40d4de0014d6
 patches: []

data/.version

@@ -1 +1 @@
-v6.4.0
+v6.5.0

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## [v6.5.0](https://github.com/auth0/ruby-auth0/tree/v6.5.0) (2026-10-14)
+[Full Changelog](https://github.com/auth0/ruby-auth0/compare/v6.4.0...v6.5.0)
+
+**Added**
+- feat: add Client Profiles, Captcha Policies, and client and client grant search, and remove update_status from experiments and feature flags [\#812](https://github.com/auth0/ruby-auth0/pull/812) ([fern-api[bot]](https://github.com/apps/fern-api))
+
+**Fixed**
+- fix: preserve false values in model fields [\#811](https://github.com/auth0/ruby-auth0/pull/811) ([kishore7snehil](https://github.com/kishore7snehil))
+
 ## [v6.4.0](https://github.com/auth0/ruby-auth0/tree/v6.4.0) (2026-09-30)
 [Full Changelog](https://github.com/auth0/ruby-auth0/compare/v6.3.0...v6.4.0)
 

data/examples/ruby-api/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../..
   specs:
-    auth0 (6.4.0)
+    auth0 (6.5.0)
       addressable (~> 2.8)
       jwt (>= 2.7, < 4.0)
       rest-client (~> 2.1)

data/lib/auth0/attack_protection/brute_force_protection/types/update_brute_force_settings_request_content.rb

@@ -14,6 +14,8 @@ module Auth0
           field :mode, -> { Auth0::Types::BruteForceProtectionModeEnum }, optional: true, nullable: false
 
           field :max_attempts, -> { Integer }, optional: true, nullable: false
+
+          field :form_submission_mode, -> { Auth0::Types::BruteForceProtectionFormSubmissionModeEnum }, optional: true, nullable: false
         end
       end
     end

data/lib/auth0/attack_protection/captcha_policies/client.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Auth0
+  module AttackProtection
+    module CaptchaPolicies
+      class Client
+        # @param client [Auth0::Internal::Http::RawClient]
+        #
+        # @return [void]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Retrieve all CAPTCHA attack protection policies for the tenant, sorted by priority ascending.
+        #
+        # @param request_options [Hash]
+        # @param _params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        #
+        # @example
+        #   client.attack_protection.captcha_policies.list
+        #
+        # @return [Array[Auth0::Types::AttackProtectionCaptchaPolicy]]
+        def list(request_options: {}, **_params)
+          request = Auth0::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "GET",
+            path: "attack-protection/captcha/policies",
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Auth0::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          if code.between?(200, 299)
+            (response.body.to_s.empty? ? nil : Auth0::Types::ListAttackProtectionCaptchaPoliciesResponseContent.load(response.body))
+          else
+            error_class = Auth0::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # Create a new CAPTCHA attack protection policy for the tenant. The maximum number of policies per tenant is
+        # determined by the tenant's subscription.
+        #
+        # @param request_options [Hash]
+        # @param params [Auth0::AttackProtection::CaptchaPolicies::Types::CreateAttackProtectionCaptchaPolicyRequestContent]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        #
+        # @example
+        #   client.attack_protection.captcha_policies.create(
+        #     name: "name",
+        #     priority: 1,
+        #     match: {},
+        #     action: {}
+        #   )
+        #
+        # @return [Auth0::Types::AttackProtectionCaptchaPolicy]
+        def create(request_options: {}, **params)
+          params = Auth0::Internal::Types::Utils.normalize_keys(params)
+          request = Auth0::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "POST",
+            path: "attack-protection/captcha/policies",
+            body: Auth0::AttackProtection::CaptchaPolicies::Types::CreateAttackProtectionCaptchaPolicyRequestContent.new(params).to_h,
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Auth0::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          if code.between?(200, 299)
+            (response.body.to_s.empty? ? nil : Auth0::Types::AttackProtectionCaptchaPolicy.load(response.body))
+          else
+            error_class = Auth0::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # Retrieve a single CAPTCHA attack protection policy for the tenant by ID.
+        #
+        # @param request_options [Hash]
+        # @param params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String] :id
+        #
+        # @example
+        #   client.attack_protection.captcha_policies.get(id: "id")
+        #
+        # @return [Auth0::Types::AttackProtectionCaptchaPolicy]
+        def get(request_options: {}, **params)
+          params = Auth0::Internal::Types::Utils.normalize_keys(params)
+          request = Auth0::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "GET",
+            path: "attack-protection/captcha/policies/#{URI.encode_uri_component(params[:id].to_s)}",
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Auth0::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          if code.between?(200, 299)
+            (response.body.to_s.empty? ? nil : Auth0::Types::AttackProtectionCaptchaPolicy.load(response.body))
+          else
+            error_class = Auth0::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+
+        # Delete a CAPTCHA attack protection policy for the tenant.
+        #
+        # @param request_options [Hash]
+        # @param params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String] :id
+        #
+        # @example
+        #   client.attack_protection.captcha_policies.delete(id: "id")
+        #
+        # @return [untyped]
+        def delete(request_options: {}, **params)
+          params = Auth0::Internal::Types::Utils.normalize_keys(params)
+          request = Auth0::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "DELETE",
+            path: "attack-protection/captcha/policies/#{URI.encode_uri_component(params[:id].to_s)}",
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Auth0::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          return if code.between?(200, 299)
+
+          error_class = Auth0::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+
+        # Partially update a CAPTCHA attack protection policy. Only the provided fields are modified. A provided match
+        # or action replaces the stored value in full rather than merging with it; within action, a provider secret or
+        # API key that is omitted from a provided provider block keeps its stored value.
+        #
+        # @param request_options [Hash]
+        # @param params [Auth0::AttackProtection::CaptchaPolicies::Types::UpdateAttackProtectionCaptchaPolicyRequestContent]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String] :id
+        #
+        # @example
+        #   client.attack_protection.captcha_policies.update(id: "id")
+        #
+        # @return [Auth0::Types::AttackProtectionCaptchaPolicy]
+        def update(request_options: {}, **params)
+          params = Auth0::Internal::Types::Utils.normalize_keys(params)
+          request_data = Auth0::AttackProtection::CaptchaPolicies::Types::UpdateAttackProtectionCaptchaPolicyRequestContent.new(params).to_h
+          non_body_param_names = %w[id]
+          body = request_data.except(*non_body_param_names)
+
+          request = Auth0::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "PATCH",
+            path: "attack-protection/captcha/policies/#{URI.encode_uri_component(params[:id].to_s)}",
+            body: body,
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Auth0::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          if code.between?(200, 299)
+            (response.body.to_s.empty? ? nil : Auth0::Types::AttackProtectionCaptchaPolicy.load(response.body))
+          else
+            error_class = Auth0::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/auth0/attack_protection/captcha_policies/types/create_attack_protection_captcha_policy_request_content.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Auth0
+  module AttackProtection
+    module CaptchaPolicies
+      module Types
+        class CreateAttackProtectionCaptchaPolicyRequestContent < Internal::Types::Model
+          field :name, -> { String }, optional: false, nullable: false
+
+          field :description, -> { String }, optional: true, nullable: false
+
+          field :priority, -> { Integer }, optional: false, nullable: false
+
+          field :match, -> { Auth0::Types::AttackProtectionCaptchaPolicyMatch }, optional: false, nullable: false
+
+          field :action, -> { Auth0::Types::AttackProtectionCaptchaPolicyActionInput }, optional: false, nullable: false
+        end
+      end
+    end
+  end
+end

data/lib/auth0/attack_protection/captcha_policies/types/update_attack_protection_captcha_policy_request_content.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Auth0
+  module AttackProtection
+    module CaptchaPolicies
+      module Types
+        class UpdateAttackProtectionCaptchaPolicyRequestContent < Internal::Types::Model
+          field :id, -> { String }, optional: false, nullable: false
+
+          field :name, -> { String }, optional: true, nullable: false
+
+          field :description, -> { String }, optional: true, nullable: false
+
+          field :priority, -> { Integer }, optional: true, nullable: false
+
+          field :match, -> { Auth0::Types::AttackProtectionCaptchaPolicyMatch }, optional: true, nullable: false
+
+          field :action, -> { Auth0::Types::AttackProtectionCaptchaPolicyActionInput }, optional: true, nullable: false
+        end
+      end
+    end
+  end
+end

data/lib/auth0/attack_protection/client.rb

@@ -30,6 +30,11 @@ module Auth0
         @captcha ||= Auth0::AttackProtection::Captcha::Client.new(client: @client)
       end
 
+      # @return [Auth0::CaptchaPolicies::Client]
+      def captcha_policies
+        @captcha_policies ||= Auth0::AttackProtection::CaptchaPolicies::Client.new(client: @client)
+      end
+
       # @return [Auth0::PhoneProviderProtection::Client]
       def phone_provider_protection
         @phone_provider_protection ||= Auth0::AttackProtection::PhoneProviderProtection::Client.new(client: @client)

data/lib/auth0/client.rb

@@ -43,6 +43,11 @@ module Auth0
       @client_grants ||= Auth0::ClientGrants::Client.new(client: @raw_client)
     end
 
+    # @return [Auth0::ClientProfiles::Client]
+    def client_profiles
+      @client_profiles ||= Auth0::ClientProfiles::Client.new(client: @raw_client)
+    end
+
     # @return [Auth0::Clients::Client]
     def clients
       @clients ||= Auth0::Clients::Client.new(client: @raw_client)

data/lib/auth0/client_grants/client.rb

@@ -122,6 +122,78 @@ module Auth0
         end
       end
 
+      # Search client grants using SCIM or Lucene filter syntax with low-latency, eventually consistent results. Use the
+      # parser parameter to specify "scim" or "lucene" syntax (default: "lucene"). This endpoint provides an alternative
+      # to the standard GET /client-grants endpoint with better performance for complex queries.
+      # Results may not reflect recent updates immediately.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :q
+      # @option params [Auth0::Types::SearchParserEnum, nil] :parser
+      # @option params [String, nil] :fields
+      # @option params [Boolean, nil] :include_fields
+      # @option params [Integer, nil] :take
+      # @option params [String, nil] :from
+      # @option params [Auth0::Types::ClientGrantSortFieldEnum, nil] :sort
+      #
+      # @example
+      #   client.client_grants.search(
+      #     q: "q",
+      #     parser: "scim",
+      #     fields: "fields",
+      #     include_fields: true,
+      #     take: 1,
+      #     from: "from",
+      #     sort: "audience"
+      #   )
+      #
+      # @return [Auth0::Types::SearchClientGrantsResponseContent]
+      def search(request_options: {}, **params)
+        params = Auth0::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["q"] = params[:q] if params.key?(:q)
+        query_params["parser"] = params[:parser] if params.key?(:parser)
+        query_params["fields"] = params[:fields] if params.key?(:fields)
+        query_params["include_fields"] = params[:include_fields] if params.key?(:include_fields)
+        query_params["take"] = params.fetch(:take, 50)
+        query_params["from"] = params[:from] if params.key?(:from)
+        query_params["sort"] = params[:sort] if params.key?(:sort)
+
+        Auth0::Internal::CursorItemIterator.new(
+          cursor_field: :next_,
+          item_field: :client_grants,
+          initial_cursor: query_params["from"]
+        ) do |next_cursor|
+          query_params["from"] = next_cursor
+          request = Auth0::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "GET",
+            path: "client-grants/search",
+            query: query_params,
+            request_options: request_options
+          )
+          begin
+            response = @client.send(request)
+          rescue Net::HTTPRequestTimeout
+            raise Auth0::Errors::TimeoutError
+          end
+          code = response.code.to_i
+          if code.between?(200, 299)
+            parsed_response = (response.body.to_s.empty? ? nil : Auth0::Types::SearchClientGrantsResponseContent.load(response.body))
+            [parsed_response, response]
+          else
+            error_class = Auth0::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
+        end
+      end
+
       # Retrieve a single [client
       # grant](https://auth0.com/docs/get-started/applications/application-access-to-apis-client-grants), including the
       # scopes associated with the application/API pair.

data/lib/auth0/client_grants/types/search_client_grants_request_parameters.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Auth0
+  module ClientGrants
+    module Types
+      class SearchClientGrantsRequestParameters < Internal::Types::Model
+        field :q, -> { String }, optional: true, nullable: false
+
+        field :parser, -> { Auth0::Types::SearchParserEnum }, optional: true, nullable: false
+
+        field :fields, -> { String }, optional: true, nullable: false
+
+        field :include_fields, -> { Internal::Types::Boolean }, optional: true, nullable: false
+
+        field :take, -> { Integer }, optional: true, nullable: false
+
+        field :from, -> { String }, optional: true, nullable: false
+
+        field :sort, -> { Auth0::Types::ClientGrantSortFieldEnum }, optional: true, nullable: false
+      end
+    end
+  end
+end