descope 1.1.0 → 1.2.0

data/lib/descope/api/v1/auth/enchantedlink.rb

@@ -17,7 +17,17 @@ module Descope
             validate_refresh_token_provided(login_options, refresh_token)
             body = enchanted_link_compose_signin_body(login_id, uri, login_options)
             uri = enchanted_link_compose_signin_url
-            post(uri, body, nil, refresh_token)
+            post(uri, body, {}, refresh_token)
+          end
+
+          def enchanted_link_sign_in_with_phone(login_id: nil, uri: nil, login_options: nil, provider_id: nil, template_id: nil, refresh_token: nil)
+            validate_login_id(login_id)
+            validate_refresh_token_provided(login_options, refresh_token)
+            body = enchanted_link_compose_signin_body(login_id, uri, login_options)
+            body[:providerId] = provider_id if provider_id
+            body[:templateId] = template_id if template_id
+            uri = enchanted_link_compose_signin_url(Descope::Mixins::Common::DeliveryMethod::SMS)
+            post(uri, body, {}, refresh_token)
           end
 
           def enchanted_link_sign_up(login_id: nil, uri: nil, user: {})
@@ -36,6 +46,23 @@ module Descope
             post(uri, body)
           end
 
+          def enchanted_link_sign_up_with_phone(login_id: nil, uri: nil, user: {}, provider_id: nil, template_id: nil)
+            method = Descope::Mixins::Common::DeliveryMethod::SMS
+
+            unless adjust_and_verify_delivery_method(method, login_id, user)
+              raise Descope::ArgumentException.new(
+                'Invalid delivery method',
+                code: 400
+              )
+            end
+
+            body = enchanted_link_compose_signup_body(login_id, uri, user, method)
+            body[:providerId] = provider_id if provider_id
+            body[:templateId] = template_id if template_id
+            uri = enchanted_link_compose_signup_url(method)
+            post(uri, body)
+          end
+
           def enchanted_link_sign_up_or_in(login_id: nil, uri: nil, login_options: nil)
             # @see https://docs.descope.com/api/openapi/enchantedlink/operation/SignUpOrInEnchantedLinkEmail/
             body = enchanted_link_compose_signin_body(login_id, uri, login_options)
@@ -43,6 +70,14 @@ module Descope
             post(uri, body)
           end
 
+          def enchanted_link_sign_up_or_in_with_phone(login_id: nil, uri: nil, login_options: nil, provider_id: nil, template_id: nil)
+            body = enchanted_link_compose_signin_body(login_id, uri, login_options)
+            body[:providerId] = provider_id if provider_id
+            body[:templateId] = template_id if template_id
+            uri = enchanted_link_compose_sign_up_or_in_url(Descope::Mixins::Common::DeliveryMethod::SMS)
+            post(uri, body)
+          end
+
           def enchanted_link_update_user_email(login_id: nil, email: nil, uri: nil, add_to_login_ids: nil, on_merge_use_existing: nil, provider_id: nil, template_id: nil, template_options: nil, refresh_token: nil)
             validate_login_id(login_id)
             validate_token_not_empty(refresh_token)
@@ -59,6 +94,22 @@ module Descope
             post(uri, body, {}, refresh_token)
           end
 
+          def enchanted_link_update_user_phone(login_id: nil, phone: nil, uri: nil, add_to_login_ids: nil, on_merge_use_existing: nil, provider_id: nil, template_id: nil, template_options: nil, refresh_token: nil)
+            validate_login_id(login_id)
+            validate_token_not_empty(refresh_token)
+            validate_phone(Descope::Mixins::Common::DeliveryMethod::SMS, phone)
+
+            body = enchanted_link_compose_update_user_phone_body(
+              login_id, phone, add_to_login_ids, on_merge_use_existing
+            )
+            body[:redirectUrl] = uri
+            body[:providerId] = provider_id if provider_id
+            body[:templateId] = template_id if template_id
+            body[:templateOptions] = template_options if template_options
+            uri = compose_url(UPDATE_USER_PHONE_ENCHANTEDLINK_PATH, Descope::Mixins::Common::DeliveryMethod::SMS)
+            post(uri, body, {}, refresh_token)
+          end
+
           def enchanted_link_verify_token(token = nil)
             validate_token_not_empty(token)
             post(VERIFY_ENCHANTEDLINK_AUTH_PATH, { token: })
@@ -97,19 +148,23 @@ module Descope
             body
           end
 
-          def enchanted_link_compose_signin_url
-            compose_url(SIGN_IN_AUTH_ENCHANTEDLINK_PATH, Descope::Mixins::Common::DeliveryMethod::EMAIL)
+          def enchanted_link_compose_signin_url(method = nil)
+            method = Descope::Mixins::Common::DeliveryMethod::EMAIL if method.nil?
+            compose_url(SIGN_IN_AUTH_ENCHANTEDLINK_PATH, method)
           end
 
-          def enchanted_link_compose_signup_url
-            compose_url(SIGN_UP_AUTH_ENCHANTEDLINK_PATH, Descope::Mixins::Common::DeliveryMethod::EMAIL)
+          def enchanted_link_compose_signup_url(method = nil)
+            method = Descope::Mixins::Common::DeliveryMethod::EMAIL if method.nil?
+            compose_url(SIGN_UP_AUTH_ENCHANTEDLINK_PATH, method)
           end
 
-          def enchanted_link_compose_sign_up_or_in_url
-            compose_url(SIGN_UP_OR_IN_AUTH_ENCHANTEDLINK_PATH, Descope::Mixins::Common::DeliveryMethod::EMAIL)
+          def enchanted_link_compose_sign_up_or_in_url(method = nil)
+            method = Descope::Mixins::Common::DeliveryMethod::EMAIL if method.nil?
+            compose_url(SIGN_UP_OR_IN_AUTH_ENCHANTEDLINK_PATH, method)
           end
 
-          def enchanted_link_compose_signup_body(login_id, uri, user)
+          def enchanted_link_compose_signup_body(login_id, uri, user, method = nil)
+            method = Descope::Mixins::Common::DeliveryMethod::EMAIL if method.nil?
             body = {
               loginId: login_id,
               redirectUrl: uri
@@ -118,7 +173,7 @@ module Descope
             unless user.nil? || user.empty?
               body[:user] = enchantedlink_user_compose_update_body(**user) unless user.empty?
 
-              method_str, val = get_login_id_by_method(method: Descope::Mixins::Common::DeliveryMethod::EMAIL, user:)
+              method_str, val = get_login_id_by_method(method:, user:)
               body[method_str.to_sym] = val
             end
 
@@ -137,6 +192,18 @@ module Descope
             body
           end
 
+          def enchanted_link_compose_update_user_phone_body(login_id, phone, add_to_login_ids, on_merge_use_existing)
+            body = {
+              loginId: login_id,
+              phone:
+            }
+
+            body[:addToLoginIDs] = add_to_login_ids if add_to_login_ids
+            body[:onMergeUseExisting] = on_merge_use_existing if on_merge_use_existing
+
+            body
+          end
+
 
           private
           def enchantedlink_user_compose_update_body(login_id: nil, name: nil, phone: nil, email: nil, given_name: nil, middle_name: nil, family_name: nil)

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

@@ -16,7 +16,8 @@ module Descope
             role_names ||= []
             key_tenants ||= []
             validate_tenants(key_tenants)
-            post(ACCESS_KEY_CREATE_PATH, access_key_compose_create_body(name, expire_time, role_names, key_tenants, custom_claims))
+            mgmt_post(ACCESS_KEY_CREATE_PATH,
+                      access_key_compose_create_body(name, expire_time, role_names, key_tenants, custom_claims))
           end
 
           def access_key_compose_create_body(name, expire_time, role_names, key_tenants, custom_claims)
@@ -34,7 +35,7 @@ module Descope
             # @param id [string] The access key id.
             # @see https://docs.descope.com/api/openapi/accesskeymanagement/operation/LoadAccessKey/
 
-            get(ACCESS_KEY_LOAD_PATH, { id: })
+            mgmt_get(ACCESS_KEY_LOAD_PATH, { id: })
           end
 
           def search_all_access_keys(tenant_ids = nil)
@@ -43,7 +44,7 @@ module Descope
             request_params = {
               tenantIds: tenant_ids
             }
-            post(ACCESS_KEYS_SEARCH_PATH, request_params)
+            mgmt_post(ACCESS_KEYS_SEARCH_PATH, request_params)
           end
 
           def update_access_key(id: nil, name: nil)
@@ -53,27 +54,27 @@ module Descope
               id:,
               name:
             }
-            post(ACCESS_KEY_UPDATE_PATH, request_params)
+            mgmt_post(ACCESS_KEY_UPDATE_PATH, request_params)
           end
 
           def deactivate_access_key(id)
             # Deactivate an existing access key. IMPORTANT: This deactivated key will not be usable from this stage.
             # It will, however, persist, and can be activated again if needed.
             # @see https://docs.descope.com/api/openapi/accesskeymanagement/operation/DeactivateAccessKey/
-            post(ACCESS_KEY_DEACTIVATE_PATH, { id: })
+            mgmt_post(ACCESS_KEY_DEACTIVATE_PATH, { id: })
           end
 
           def activate_access_key(id)
             # Activate an existing access key. IMPORTANT: Only deactivated keys can be activated again,
             # and become usable once more. New access keys are active by default.
             # @see https://docs.descope.com/api/openapi/accesskeymanagement/operation/ActivateAccessKey/
-            post(ACCESS_KEY_ACTIVATE_PATH, { id: })
+            mgmt_post(ACCESS_KEY_ACTIVATE_PATH, { id: })
           end
 
           def delete_access_key(id)
             # Delete an existing access key. IMPORTANT: This action is irreversible. Use carefully.
             # @see https://docs.descope.com/api/openapi/accesskeymanagement/operation/DeleteAccessKey/
-            post(ACCESS_KEY_DELETE_PATH, { id: })
+            mgmt_post(ACCESS_KEY_DELETE_PATH, { id: })
           end
         end
       end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Descope
+  module Api
+    module V1
+      module Management
+        # Management API calls for analytics
+        module Analytics
+          include Descope::Api::V1::Management::Common
+
+          def analytics_search(
+            from_ts:,
+            to_ts:,
+            actions: nil,
+            excluded_actions: nil,
+            devices: nil,
+            methods: nil,
+            geos: nil,
+            tenants: nil,
+            group_by_action: false,
+            group_by_device: false,
+            group_by_method: false,
+            group_by_geo: false,
+            group_by_tenant: false,
+            group_by_referrer: false,
+            group_by_created: false
+          )
+            # Search project analytics based on given parameters
+            # from_ts (int): Retrieve records newer than given time in epoch milliseconds
+            # to_ts (int): Retrieve records older than given time in epoch milliseconds
+            # actions (Array): Optional list of actions to filter by
+            # excluded_actions (Array): Optional list of actions to exclude
+            # devices (Array): Optional list of devices to filter by
+            # methods (Array): Optional list of methods to filter by
+            # geos (Array): Optional list of geos to filter by. Geo is currently country code like "US", "IL", etc.
+            # tenants (Array): Optional list of tenants to filter by
+            # group_by_* (bool): Optional grouping flags for the returned analytics
+            request_params = {
+              from: from_ts,
+              to: to_ts,
+              groupByAction: group_by_action,
+              groupByDevice: group_by_device,
+              groupByMethod: group_by_method,
+              groupByGeo: group_by_geo,
+              groupByTenant: group_by_tenant,
+              groupByReferrer: group_by_referrer,
+              groupByCreated: group_by_created
+            }
+            request_params[:actions] = actions unless actions.nil?
+            request_params[:excludedActions] = excluded_actions unless excluded_actions.nil?
+            request_params[:devices] = devices unless devices.nil?
+            request_params[:methods] = methods unless methods.nil?
+            request_params[:geos] = geos unless geos.nil?
+            request_params[:tenants] = tenants unless tenants.nil?
+
+            mgmt_post(ANALYTICS_SEARCH_PATH, request_params)
+          end
+        end
+      end
+    end
+  end
+end

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