descope 1.0.7 → 1.2.0

data/lib/descope/api/v1/management/audit.rb

@@ -52,7 +52,7 @@ module Descope
             request_params[:text] = text unless text.nil?
             request_params[:from] = from_ts.to_i * 1000 unless from_ts.nil?
             request_params[:to] = to_ts.to_i * 1000 unless to_ts.nil?
-            res = post(AUDIT_SEARCH, request_params)
+            res = mgmt_post(AUDIT_SEARCH, request_params)
             raise Descope::AuthException, "could not get audits: #{res}" if res['audits'].nil?
 
             { 'audits' => res['audits'].map { |audit| convert_audit_record(audit) } }
@@ -79,7 +79,7 @@ module Descope
             }
             request_params[:userId] = user_id unless user_id.nil?
 
-            post(AUDIT_CREATE_EVENT, request_params)
+            mgmt_post(AUDIT_CREATE_EVENT, request_params)
           end
 
           private

data/lib/descope/api/v1/management/authz.rb

@@ -40,17 +40,17 @@ module Descope
             #   Schema name can be used for projects to track versioning.
             #  @see https://docs.descope.com/api/openapi/authz/operation/SaveSchema/
             request_params = { schema:, upgrade: }
-            post(AUTHZ_SCHEMA_SAVE, request_params)
+            mgmt_post(AUTHZ_SCHEMA_SAVE, request_params)
           end
 
           def authz_delete_schema
             # Delete the schema for the project which will also delete all relations.
-            post(AUTHZ_SCHEMA_DELETE)
+            mgmt_post(AUTHZ_SCHEMA_DELETE)
           end
 
           def authz_load_schema
             # Load the schema for the project.
-            post(AUTHZ_SCHEMA_LOAD)
+            mgmt_post(AUTHZ_SCHEMA_LOAD)
           end
 
           def authz_save_namespace(namespace: nil, old_name: nil, schema_name: nil)
@@ -59,14 +59,14 @@ module Descope
             request_params = { namespace: namespace }
             request_params[:oldName] = old_name unless old_name.nil?
             request_params[:schemaName] = schema_name unless schema_name.nil?
-            post(AUTHZ_NS_SAVE, request_params)
+            mgmt_post(AUTHZ_NS_SAVE, request_params)
           end
 
           def authz_delete_namespace(name: nil, schema_name: nil)
             # Delete the given namespace
             request_params = { name: name }
             request_params[:schemaName] = schema_name unless schema_name.nil?
-            post(AUTHZ_NS_DELETE, request_params)
+            mgmt_post(AUTHZ_NS_DELETE, request_params)
           end
 
           def authz_save_relation_definition(relation_definition: nil, namespace: nil, old_name: nil, schema_name: nil)
@@ -78,14 +78,14 @@ module Descope
             }
             request_params[:old_name] = old_name unless old_name.nil?
             request_params[:schemaName] = schema_name unless schema_name.nil?
-            post(AUTHZ_RD_SAVE, request_params)
+            mgmt_post(AUTHZ_RD_SAVE, request_params)
           end
 
           def authz_delete_relation_definition(name: nil, namespace: nil, schema_name: nil)
             # Delete the given relation definition
             request_params = { name: , namespace:  }
             request_params[:schemaName] = schema_name unless schema_name.nil?
-            post(AUTHZ_RD_DELETE, request_params)
+            mgmt_post(AUTHZ_RD_DELETE, request_params)
           end
 
           def authz_create_relations(relations = nil)
@@ -114,22 +114,22 @@ module Descope
             #   }
             #   Each relation should have exactly one of: target, targetSet, query
             #   Regarding query above, it should be specified if the target is a set of users that matches the query - all fields are optional
-            post(AUTHZ_RE_CREATE, { relations: })
+            mgmt_post(AUTHZ_RE_CREATE, { relations: })
           end
 
           def authz_delete_relations(relations = nil)
             # Delete the given relations based on the existing schema
-            post(AUTHZ_RE_DELETE, { relations: })
+            mgmt_post(AUTHZ_RE_DELETE, { relations: })
           end
 
           def authz_delete_relations_for_resources(resources = nil)
             # Delete all relations for the given resources
-            post(AUTHZ_RE_DELETE_RESOURCES, { resources: })
+            mgmt_post(AUTHZ_RE_DELETE_RESOURCES, { resources: })
           end
 
           def authz_has_relations?(relation_queries = nil)
             # Queries the given relations to see if they exist returning true if they do
-            post(AUTHZ_RE_HAS_RELATIONS, { relationQueries: relation_queries })
+            mgmt_post(AUTHZ_RE_HAS_RELATIONS, { relationQueries: relation_queries })
           end
 
           def authz_who_can_access?(resource: nil, relation_definition: nil, namespace: nil)
@@ -139,21 +139,21 @@ module Descope
               relationDefinition: relation_definition,
               namespace:
             }
-            post(AUTHZ_RE_WHO, request_params)
+            mgmt_post(AUTHZ_RE_WHO, request_params)
           end
 
           def authz_resource_relations(resources: nil)
-            post(AUTHZ_RE_RESOURCE, { resources: })
+            mgmt_post(AUTHZ_RE_RESOURCE, { resources: })
           end
 
           def authz_target_relations(targets: nil)
             # Returns the list of all defined relations (not recursive) for the given targets.
-            post(AUTHZ_RE_TARGETS, { targets: })
+            mgmt_post(AUTHZ_RE_TARGETS, { targets: })
           end
 
           def authz_what_can_target_access?(target: nil)
             # Returns the list of all relations for the given target including derived relations from the schema tree.
-            res = post(AUTHZ_RE_TARGET_ALL, { target: })
+            res = mgmt_post(AUTHZ_RE_TARGET_ALL, { target: })
             raise Descope::AuthException, "could not get relation for target: #{res}" if res['relations'].nil?
 
             res['relations']

data/lib/descope/api/v1/management/common.rb

@@ -141,6 +141,82 @@ module Descope
           PROJECT_IMPORT_PATH = '/v1/mgmt/project/import'
           PROJECT_DELETE_PATH = '/v1/mgmt/project/delete'
 
+          # FGA (Fine-Grained Authorization)
+          FGA_SAVE_SCHEMA_PATH = '/v1/mgmt/fga/schema'
+          FGA_LOAD_SCHEMA_PATH = '/v1/mgmt/fga/schema'
+          FGA_CREATE_RELATIONS_PATH = '/v1/mgmt/fga/relations'
+          FGA_DELETE_RELATIONS_PATH = '/v1/mgmt/fga/relations/delete'
+          FGA_CHECK_PATH = '/v1/mgmt/fga/check'
+          FGA_LOAD_MAPPABLE_SCHEMA_PATH = '/v1/mgmt/fga/mappable/schema'
+          FGA_SEARCH_MAPPABLE_RESOURCES_PATH = '/v1/mgmt/fga/mappable/resources'
+          FGA_RESOURCES_LOAD_PATH = '/v1/mgmt/fga/resources/load'
+          FGA_RESOURCES_SAVE_PATH = '/v1/mgmt/fga/resources/save'
+
+          # Third Party Application
+          THIRD_PARTY_APP_CREATE_PATH = '/v1/mgmt/thirdparty/app/create'
+          THIRD_PARTY_APP_UPDATE_PATH = '/v1/mgmt/thirdparty/app/update'
+          THIRD_PARTY_APP_PATCH_PATH = '/v1/mgmt/thirdparty/app/patch'
+          THIRD_PARTY_APP_DELETE_PATH = '/v1/mgmt/thirdparty/app/delete'
+          THIRD_PARTY_APP_LOAD_PATH = '/v1/mgmt/thirdparty/app/load'
+          THIRD_PARTY_APP_LOAD_ALL_PATH = '/v1/mgmt/thirdparty/apps/load'
+          THIRD_PARTY_APP_SECRET_PATH = '/v1/mgmt/thirdparty/app/secret'
+          THIRD_PARTY_APP_ROTATE_PATH = '/v1/mgmt/thirdparty/app/rotate'
+          THIRD_PARTY_APP_DELETE_CONSENTS_PATH = '/v1/mgmt/thirdparty/consents/delete'
+          THIRD_PARTY_APP_DELETE_TENANT_CONSENTS_PATH = '/v1/mgmt/thirdparty/consents/delete/tenant'
+
+          # Management Key
+          MGMT_KEY_CREATE_PATH = '/v1/mgmt/managementkey'
+          MGMT_KEY_UPDATE_PATH = '/v1/mgmt/managementkey'
+          MGMT_KEY_GET_PATH = '/v1/mgmt/managementkey'
+          MGMT_KEY_DELETE_PATH = '/v1/mgmt/managementkey/delete'
+          MGMT_KEY_SEARCH_PATH = '/v1/mgmt/managementkey/search'
+
+          # Analytics
+          ANALYTICS_SEARCH_PATH = '/v1/mgmt/analytics/search'
+
+          # Descoper
+          DESCOPER_CREATE_PATH = '/v1/mgmt/descoper'
+          DESCOPER_UPDATE_PATH = '/v1/mgmt/descoper'
+          DESCOPER_GET_PATH = '/v1/mgmt/descoper'
+          DESCOPER_DELETE_PATH = '/v1/mgmt/descoper'
+          DESCOPER_SEARCH_PATH = '/v1/mgmt/descoper/list'
+
+          # Engine
+          ENGINE_CREATE_PATH = '/v1/mgmt/engine/create'
+          ENGINE_UPDATE_PATH = '/v1/mgmt/engine/update'
+          ENGINE_DELETE_PATH = '/v1/mgmt/engine/delete'
+          ENGINE_LOAD_PATH = '/v1/mgmt/engine/load'
+          ENGINE_LOAD_ALL_PATH = '/v1/mgmt/engines/load'
+          ENGINE_ROTATE_SECRET_PATH = '/v1/mgmt/engine/rotate'
+
+          # List
+          LIST_CREATE_PATH = '/v1/mgmt/list'
+          LIST_UPDATE_PATH = '/v1/mgmt/list/update'
+          LIST_DELETE_PATH = '/v1/mgmt/list/delete'
+          LIST_LOAD_PATH = '/v1/mgmt/list'
+          LIST_LOAD_BY_NAME_PATH = '/v1/mgmt/list/name'
+          LIST_LOAD_ALL_PATH = '/v1/mgmt/list/all'
+          LIST_IMPORT_PATH = '/v1/mgmt/list/import'
+          LIST_ADD_IPS_PATH = '/v1/mgmt/list/ip/add'
+          LIST_REMOVE_IPS_PATH = '/v1/mgmt/list/ip/remove'
+          LIST_CHECK_IP_PATH = '/v1/mgmt/list/ip/check'
+          LIST_ADD_TEXTS_PATH = '/v1/mgmt/list/text/add'
+          LIST_REMOVE_TEXTS_PATH = '/v1/mgmt/list/text/remove'
+          LIST_CHECK_TEXT_PATH = '/v1/mgmt/list/text/check'
+          LIST_CLEAR_PATH = '/v1/mgmt/list/clear'
+
+          # JWT Template
+          JWT_TEMPLATE_CREATE_PATH = '/v1/mgmt/jwt/templates/create'
+          JWT_TEMPLATE_UPDATE_PATH = '/v1/mgmt/jwt/templates/update'
+          JWT_TEMPLATE_DELETE_PATH = '/v1/mgmt/jwt/templates/delete'
+          JWT_TEMPLATE_LIST_PATH = '/v1/mgmt/jwt/templates/list'
+          JWT_TEMPLATE_LOAD_PATH = '/v1/mgmt/jwt/templates/load'
+
+          # Scope Claim Mapping (project-wide OIDC scope-to-claim mapping)
+          SCOPE_CLAIM_MAPPING_GET_PATH = '/v1/mgmt/scopeClaimMapping/get'
+          SCOPE_CLAIM_MAPPING_SET_PATH = '/v1/mgmt/scopeClaimMapping/set'
+          SCOPE_CLAIM_MAPPING_DELETE_PATH = '/v1/mgmt/scopeClaimMapping/delete'
+
           def associated_tenants_to_hash_array(associated_tenants = [])
             # Represents a tenant association for a User or Access Key. The tenant_id is required to denote
             # which tenant the user or access key belongs to. The role_names array is an optional list of

data/lib/descope/api/v1/management/descoper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for Descoper
+        module Descoper
+          include Descope::Api::V1::Management::Common
+
+          def create_descoper(descopers = nil)
+            # Create the given descopers.
+            # descopers (Array): the descopers to create.
+            mgmt_put(DESCOPER_CREATE_PATH, { descopers: descopers })
+          end
+
+          def update_descoper(id: nil, attributes: nil, rbac: nil)
+            # Update the given descoper by id.
+            request_params = {
+              id: id,
+              attributes: attributes,
+              rbac: rbac
+            }
+            mgmt_patch(DESCOPER_UPDATE_PATH, request_params)
+          end
+
+          def get_descoper(id: nil)
+            # Get a descoper by id.
+            mgmt_get(DESCOPER_GET_PATH, { id: id })
+          end
+
+          def delete_descoper(id: nil)
+            # Delete a descoper by id.
+            mgmt_delete(DESCOPER_DELETE_PATH, { id: id })
+          end
+
+          def search_descopers
+            # Search (list) all descopers.
+            mgmt_post(DESCOPER_SEARCH_PATH, {})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/descope/api/v1/management/engine.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for Engine
+        module Engine
+          include Descope::Api::V1::Management::Common
+
+          def create_engine(name:)
+            # Create a new engine with the given name.
+            mgmt_post(ENGINE_CREATE_PATH, { name: })
+          end
+
+          def update_engine(id:, name:)
+            # Update an existing engine with the given id and name.
+            mgmt_post(ENGINE_UPDATE_PATH, { id:, name: })
+          end
+
+          def delete_engine(id:)
+            # Delete an existing engine. IMPORTANT: This action is irreversible. Use carefully.
+            mgmt_post(ENGINE_DELETE_PATH, { id: })
+          end
+
+          def load_engine(id:)
+            # Load engine by id.
+            mgmt_get(ENGINE_LOAD_PATH, { id: })
+          end
+
+          def load_all_engines
+            # Load all engines.
+            mgmt_get(ENGINE_LOAD_ALL_PATH)
+          end
+
+          def rotate_engine_secret(id:)
+            # Rotate the secret for the given engine.
+            mgmt_post(ENGINE_ROTATE_SECRET_PATH, { id: })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/descope/api/v1/management/fga.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for FGA (Fine-Grained Authorization)
+        module FGA
+          include Descope::Api::V1::Management::Common
+
+          def fga_save_schema(schema: nil)
+            # Create or update the FGA schema.
+            # schema (String): the schema DSL string.
+            mgmt_post(FGA_SAVE_SCHEMA_PATH, { dsl: schema })
+          end
+
+          def fga_load_schema
+            # Load the FGA schema for the project.
+            mgmt_get(FGA_LOAD_SCHEMA_PATH)
+          end
+
+          def fga_create_relations(tuples: nil)
+            # Create the given relations (tuples) based on the existing schema.
+            mgmt_post(FGA_CREATE_RELATIONS_PATH, { tuples: })
+          end
+
+          def fga_delete_relations(tuples: nil)
+            # Delete the given relations (tuples) based on the existing schema.
+            mgmt_post(FGA_DELETE_RELATIONS_PATH, { tuples: })
+          end
+
+          def fga_check(tuples: nil)
+            # Check the given relations (tuples) to see if they are allowed.
+            mgmt_post(FGA_CHECK_PATH, { tuples: })
+          end
+
+          def fga_load_mappable_schema(tenant_id: nil, options: nil)
+            # Load the mappable schema for the given tenant.
+            request_params = { tenantId: tenant_id }
+            request_params[:resourcesLimit] = options[:resourcesLimit] if options && options[:resourcesLimit]
+            mgmt_get(FGA_LOAD_MAPPABLE_SCHEMA_PATH, request_params)
+          end
+
+          def fga_search_mappable_resources(tenant_id: nil, resources_queries: nil, options: nil)
+            # Search for mappable resources for the given tenant.
+            request_params = { tenantId: tenant_id, resourcesQueries: resources_queries }
+            request_params[:resourcesLimit] = options[:resourcesLimit] if options && options[:resourcesLimit]
+            mgmt_post(FGA_SEARCH_MAPPABLE_RESOURCES_PATH, request_params)
+          end
+
+          def fga_load_resources_details(resource_identifiers: nil)
+            # Load the details of the given resource identifiers.
+            mgmt_post(FGA_RESOURCES_LOAD_PATH, { resourceIdentifiers: resource_identifiers })
+          end
+
+          def fga_save_resources_details(resources_details: nil)
+            # Save the details of the given resources.
+            mgmt_post(FGA_RESOURCES_SAVE_PATH, { resourcesDetails: resources_details })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/descope/api/v1/management/flow.rb

@@ -15,14 +15,14 @@ module Descope
           # To search for a flow or several flows, send a body with the flowIds you want to search such as { "ids": ["sign-in"] } or { "ids": ["sign-in", "sign-up"] }.
           def list_or_search_flows(ids = [])
             request_params = { ids: }
-            post(FLOW_LIST_PATH, request_params)
+            mgmt_post(FLOW_LIST_PATH, request_params)
           end
 
           # Export the given flow id flow and screens.
           # @see https://docs.descope.com/api/openapi/flowmanagement/operation/ExportFlow/
           def export_flow(flow_id = nil)
             request_params = { flowId: flow_id }
-            post(FLOW_EXPORT_PATH, request_params)
+            mgmt_post(FLOW_EXPORT_PATH, request_params)
           end
 
           # Import the given flow and screens.
@@ -33,20 +33,20 @@ module Descope
               flow:,
               screens:
             }
-            post(FLOW_IMPORT_PATH, request_params)
+            mgmt_post(FLOW_IMPORT_PATH, request_params)
           end
 
           # Export the current project theme.
           # @see https://docs.descope.com/api/openapi/flowmanagement/operation/ExportTheme/
           def export_theme
-            post(THEME_EXPORT_PATH)
+            mgmt_post(THEME_EXPORT_PATH)
           end
 
           # Import the current project theme.
           # @see https://docs.descope.com/api/openapi/flowmanagement/operation/ImportTheme/
           def import_theme(theme)
             request_params = { theme: }
-            post(THEME_IMPORT_PATH, request_params)
+            mgmt_post(THEME_IMPORT_PATH, request_params)
           end
         end
       end

data/lib/descope/api/v1/management/group.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for SSO groups querying
+        module Group
+          include Descope::Api::V1::Management::Common
+
+          def load_all_groups(tenant_id:)
+            # Load all groups for a given tenant id.
+            mgmt_post(GROUP_LOAD_ALL_PATH, { tenantId: tenant_id })
+          end
+
+          def load_all_groups_for_members(tenant_id:, user_ids: nil, login_ids: nil)
+            # Load all groups for the given user's or login IDs (can be given either).
+            mgmt_post(
+              GROUP_LOAD_ALL_FOR_MEMBER_PATH,
+              {
+                tenantId: tenant_id,
+                loginIds: login_ids,
+                userIds: user_ids
+              }
+            )
+          end
+
+          def load_all_group_members(tenant_id:, group_id:)
+            # Load all members of the given group id.
+            mgmt_post(
+              GROUP_LOAD_ALL_GROUP_MEMBERS_PATH,
+              {
+                tenantId: tenant_id,
+                groupId: group_id
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/descope/api/v1/management/jwt_template.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for JWT templates
+        module JWTTemplate
+          include Descope::Api::V1::Management::Common
+
+          def create_jwt_template(template: nil)
+            # Create a new JWT template.
+            # Args:
+            # template (dict): the JWT template dict with format
+            #       {
+            #           "name": "name-of-template",
+            #           "description": "description of the template",
+            #           "template": "the template body",
+            #           "conformanceIssuer": True|False,
+            #           "authSchema": "one of default|tenantOnly|none"
+            #       }
+            mgmt_post(JWT_TEMPLATE_CREATE_PATH, { template: })
+          end
+
+          def update_jwt_template(template: nil)
+            # Update an existing JWT template.
+            # The given template must include an "id" field.
+            mgmt_post(JWT_TEMPLATE_UPDATE_PATH, { template: })
+          end
+
+          def delete_jwt_template(id: nil)
+            # Delete the JWT template with the given id.
+            mgmt_post(JWT_TEMPLATE_DELETE_PATH, { id: })
+          end
+
+          def list_jwt_templates
+            # Load all JWT templates for the project.
+            mgmt_post(JWT_TEMPLATE_LIST_PATH, {})
+          end
+
+          def load_jwt_template(id: nil)
+            # Load the JWT template with the given id.
+            mgmt_post(JWT_TEMPLATE_LOAD_PATH, { id: })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/descope/api/v1/management/lists.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for the deny/allow lists (of IPs and texts)
+        module Lists
+          include Descope::Api::V1::Management::Common
+
+          def create_list(name: nil, type: nil, description: nil, data: nil)
+            # Create a new list with the given name and type.
+            body = { name:, type: }
+            body[:description] = description unless description.nil?
+            body[:data] = data unless data.nil?
+            mgmt_post(LIST_CREATE_PATH, body)
+          end
+
+          def update_list(id: nil, name: nil, type: nil, description: nil, data: nil)
+            # Update an existing list. IMPORTANT: All parameters are used as overrides to the existing list.
+            body = { id:, name:, type: }
+            body[:description] = description unless description.nil?
+            body[:data] = data unless data.nil?
+            mgmt_post(LIST_UPDATE_PATH, body)
+          end
+
+          def delete_list(id: nil)
+            # Delete an existing list. IMPORTANT: This action is irreversible. Use carefully.
+            mgmt_post(LIST_DELETE_PATH, { id: })
+          end
+
+          def load_list(id: nil)
+            # Load list by id.
+            mgmt_get("#{LIST_LOAD_PATH}/#{id}")
+          end
+
+          def load_list_by_name(name: nil)
+            # Load list by name.
+            mgmt_get("#{LIST_LOAD_BY_NAME_PATH}/#{name}")
+          end
+
+          def load_all_lists
+            # Load all lists.
+            mgmt_get(LIST_LOAD_ALL_PATH)
+          end
+
+          def import_lists(lists: nil)
+            # Import the given lists.
+            mgmt_post(LIST_IMPORT_PATH, { lists: })
+          end
+
+          def list_add_ips(id: nil, ips: nil)
+            # Add the given IPs to the list with the given id.
+            mgmt_post(LIST_ADD_IPS_PATH, { id:, ips: })
+          end
+
+          def list_remove_ips(id: nil, ips: nil)
+            # Remove the given IPs from the list with the given id.
+            mgmt_post(LIST_REMOVE_IPS_PATH, { id:, ips: })
+          end
+
+          def list_check_ip(id: nil, ip: nil)
+            # Check whether the given IP exists in the list with the given id.
+            mgmt_post(LIST_CHECK_IP_PATH, { id:, ip: })
+          end
+
+          def list_add_texts(id: nil, texts: nil)
+            # Add the given texts to the list with the given id.
+            mgmt_post(LIST_ADD_TEXTS_PATH, { id:, texts: })
+          end
+
+          def list_remove_texts(id: nil, texts: nil)
+            # Remove the given texts from the list with the given id.
+            mgmt_post(LIST_REMOVE_TEXTS_PATH, { id:, texts: })
+          end
+
+          def list_check_text(id: nil, text: nil)
+            # Check whether the given text exists in the list with the given id.
+            mgmt_post(LIST_CHECK_TEXT_PATH, { id:, text: })
+          end
+
+          def list_check_texts(id: nil, texts: nil, match_all: false)
+            # Check whether the given texts exist in the list with the given id (up to 100 texts).
+            # By default it is enough for any of the texts to exist; set match_all to require all of them.
+            mgmt_post(LIST_CHECK_TEXT_PATH, { id:, texts:, matchAll: match_all })
+          end
+
+          def clear_list(id: nil)
+            # Clear all entries from the list with the given id.
+            mgmt_post(LIST_CLEAR_PATH, { id: })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/descope/api/v1/management/management_key.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for management keys
+        module ManagementKey
+          include Descope::Api::V1::Management::Common
+
+          def create_management_key(name:, description: nil, expires_in: 0, permitted_ips: nil, re_bac: nil)
+            # Create a new management key.
+            mgmt_put(MGMT_KEY_CREATE_PATH, {
+                  name:,
+                  description:,
+                  expiresIn: expires_in,
+                  permittedIps: permitted_ips,
+                  reBac: re_bac
+                })
+          end
+
+          def update_management_key(id:, name:, description: nil, permitted_ips: nil, status: nil)
+            # Update an existing management key.
+            mgmt_patch(MGMT_KEY_UPDATE_PATH, {
+                    id:,
+                    name:,
+                    description:,
+                    permittedIps: permitted_ips,
+                    status:
+                  })
+          end
+
+          def get_management_key(id:)
+            # Load an existing management key.
+            mgmt_get(MGMT_KEY_GET_PATH, { id: })
+          end
+
+          def delete_management_key(id:)
+            # Delete an existing management key.
+            mgmt_post(MGMT_KEY_DELETE_PATH, { ids: [id] })
+          end
+
+          def search_management_keys(tenant_ids: nil, status: nil)
+            # Search all management keys.
+            mgmt_get(MGMT_KEY_SEARCH_PATH, {
+                  tenantIds: tenant_ids,
+                  status:
+                })
+          end
+        end
+      end
+    end
+  end
+end