akeyless 5.0.28 → 5.0.31

data/lib/akeyless/api/v2_api.rb

@@ -5279,6 +5279,198 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param create_mcp_secret_bearer_token [CreateMcpSecretBearerToken] 
+    # @param [Hash] opts the optional parameters
+    # @return [CreateSecretOutput]
+    def create_mcp_secret_bearer_token(create_mcp_secret_bearer_token, opts = {})
+      data, _status_code, _headers = create_mcp_secret_bearer_token_with_http_info(create_mcp_secret_bearer_token, opts)
+      data
+    end
+
+    # @param create_mcp_secret_bearer_token [CreateMcpSecretBearerToken] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CreateSecretOutput, Integer, Hash)>] CreateSecretOutput data, response status code and response headers
+    def create_mcp_secret_bearer_token_with_http_info(create_mcp_secret_bearer_token, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.create_mcp_secret_bearer_token ...'
+      end
+      # verify the required parameter 'create_mcp_secret_bearer_token' is set
+      if @api_client.config.client_side_validation && create_mcp_secret_bearer_token.nil?
+        fail ArgumentError, "Missing the required parameter 'create_mcp_secret_bearer_token' when calling V2Api.create_mcp_secret_bearer_token"
+      end
+      # resource path
+      local_var_path = '/create-mcp-secret-bearer-token'
+
+      # 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(create_mcp_secret_bearer_token)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'CreateSecretOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.create_mcp_secret_bearer_token",
+        :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: V2Api#create_mcp_secret_bearer_token\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param create_mcp_secret_o_auth_auth_code [CreateMcpSecretOAuthAuthCode] 
+    # @param [Hash] opts the optional parameters
+    # @return [CreateSecretOutput]
+    def create_mcp_secret_o_auth_auth_code(create_mcp_secret_o_auth_auth_code, opts = {})
+      data, _status_code, _headers = create_mcp_secret_o_auth_auth_code_with_http_info(create_mcp_secret_o_auth_auth_code, opts)
+      data
+    end
+
+    # @param create_mcp_secret_o_auth_auth_code [CreateMcpSecretOAuthAuthCode] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CreateSecretOutput, Integer, Hash)>] CreateSecretOutput data, response status code and response headers
+    def create_mcp_secret_o_auth_auth_code_with_http_info(create_mcp_secret_o_auth_auth_code, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.create_mcp_secret_o_auth_auth_code ...'
+      end
+      # verify the required parameter 'create_mcp_secret_o_auth_auth_code' is set
+      if @api_client.config.client_side_validation && create_mcp_secret_o_auth_auth_code.nil?
+        fail ArgumentError, "Missing the required parameter 'create_mcp_secret_o_auth_auth_code' when calling V2Api.create_mcp_secret_o_auth_auth_code"
+      end
+      # resource path
+      local_var_path = '/create-mcp-secret-oauth-authorization-code'
+
+      # 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(create_mcp_secret_o_auth_auth_code)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'CreateSecretOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.create_mcp_secret_o_auth_auth_code",
+        :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: V2Api#create_mcp_secret_o_auth_auth_code\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param create_mcp_secret_o_auth_client_creds [CreateMcpSecretOAuthClientCreds] 
+    # @param [Hash] opts the optional parameters
+    # @return [CreateSecretOutput]
+    def create_mcp_secret_o_auth_client_creds(create_mcp_secret_o_auth_client_creds, opts = {})
+      data, _status_code, _headers = create_mcp_secret_o_auth_client_creds_with_http_info(create_mcp_secret_o_auth_client_creds, opts)
+      data
+    end
+
+    # @param create_mcp_secret_o_auth_client_creds [CreateMcpSecretOAuthClientCreds] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CreateSecretOutput, Integer, Hash)>] CreateSecretOutput data, response status code and response headers
+    def create_mcp_secret_o_auth_client_creds_with_http_info(create_mcp_secret_o_auth_client_creds, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.create_mcp_secret_o_auth_client_creds ...'
+      end
+      # verify the required parameter 'create_mcp_secret_o_auth_client_creds' is set
+      if @api_client.config.client_side_validation && create_mcp_secret_o_auth_client_creds.nil?
+        fail ArgumentError, "Missing the required parameter 'create_mcp_secret_o_auth_client_creds' when calling V2Api.create_mcp_secret_o_auth_client_creds"
+      end
+      # resource path
+      local_var_path = '/create-mcp-secret-oauth-client-credentials'
+
+      # 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(create_mcp_secret_o_auth_client_creds)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'CreateSecretOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.create_mcp_secret_o_auth_client_creds",
+        :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: V2Api#create_mcp_secret_o_auth_client_creds\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param create_native_k8_s_target [CreateNativeK8STarget] 
     # @param [Hash] opts the optional parameters
     # @return [CreateNativeK8STargetOutput]
@@ -29994,27 +30186,27 @@ module Akeyless
       return data, status_code, headers
     end
 
-    # @param target_create_artifactory [TargetCreateArtifactory] 
+    # @param target_create_aerospike [TargetCreateAerospike] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
-    def target_create_artifactory(target_create_artifactory, opts = {})
-      data, _status_code, _headers = target_create_artifactory_with_http_info(target_create_artifactory, opts)
+    def target_create_aerospike(target_create_aerospike, opts = {})
+      data, _status_code, _headers = target_create_aerospike_with_http_info(target_create_aerospike, opts)
       data
     end
 
-    # @param target_create_artifactory [TargetCreateArtifactory] 
+    # @param target_create_aerospike [TargetCreateAerospike] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
-    def target_create_artifactory_with_http_info(target_create_artifactory, opts = {})
+    def target_create_aerospike_with_http_info(target_create_aerospike, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_create_artifactory ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_aerospike ...'
       end
-      # verify the required parameter 'target_create_artifactory' is set
-      if @api_client.config.client_side_validation && target_create_artifactory.nil?
-        fail ArgumentError, "Missing the required parameter 'target_create_artifactory' when calling V2Api.target_create_artifactory"
+      # verify the required parameter 'target_create_aerospike' is set
+      if @api_client.config.client_side_validation && target_create_aerospike.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_aerospike' when calling V2Api.target_create_aerospike"
       end
       # resource path
-      local_var_path = '/target-create-artifactory'
+      local_var_path = '/target-create-aerospike'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -30033,7 +30225,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_artifactory)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_aerospike)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetCreateOutput'
@@ -30042,7 +30234,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_create_artifactory",
+        :operation => :"V2Api.target_create_aerospike",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -30053,32 +30245,32 @@ module Akeyless
 
       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: V2Api#target_create_artifactory\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_create_aerospike\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_create_aws [TargetCreateAws] 
+    # @param target_create_anthropic [TargetCreateAnthropic] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
-    def target_create_aws(target_create_aws, opts = {})
-      data, _status_code, _headers = target_create_aws_with_http_info(target_create_aws, opts)
+    def target_create_anthropic(target_create_anthropic, opts = {})
+      data, _status_code, _headers = target_create_anthropic_with_http_info(target_create_anthropic, opts)
       data
     end
 
-    # @param target_create_aws [TargetCreateAws] 
+    # @param target_create_anthropic [TargetCreateAnthropic] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
-    def target_create_aws_with_http_info(target_create_aws, opts = {})
+    def target_create_anthropic_with_http_info(target_create_anthropic, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_create_aws ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_anthropic ...'
       end
-      # verify the required parameter 'target_create_aws' is set
-      if @api_client.config.client_side_validation && target_create_aws.nil?
-        fail ArgumentError, "Missing the required parameter 'target_create_aws' when calling V2Api.target_create_aws"
+      # verify the required parameter 'target_create_anthropic' is set
+      if @api_client.config.client_side_validation && target_create_anthropic.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_anthropic' when calling V2Api.target_create_anthropic"
       end
       # resource path
-      local_var_path = '/target-create-aws'
+      local_var_path = '/target-create-anthropic'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -30097,7 +30289,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_aws)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_anthropic)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetCreateOutput'
@@ -30106,7 +30298,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_create_aws",
+        :operation => :"V2Api.target_create_anthropic",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -30117,32 +30309,32 @@ module Akeyless
 
       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: V2Api#target_create_aws\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_create_anthropic\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_create_azure [TargetCreateAzure] 
+    # @param target_create_artifactory [TargetCreateArtifactory] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
-    def target_create_azure(target_create_azure, opts = {})
-      data, _status_code, _headers = target_create_azure_with_http_info(target_create_azure, opts)
+    def target_create_artifactory(target_create_artifactory, opts = {})
+      data, _status_code, _headers = target_create_artifactory_with_http_info(target_create_artifactory, opts)
       data
     end
 
-    # @param target_create_azure [TargetCreateAzure] 
+    # @param target_create_artifactory [TargetCreateArtifactory] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
-    def target_create_azure_with_http_info(target_create_azure, opts = {})
+    def target_create_artifactory_with_http_info(target_create_artifactory, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_create_azure ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_artifactory ...'
       end
-      # verify the required parameter 'target_create_azure' is set
-      if @api_client.config.client_side_validation && target_create_azure.nil?
-        fail ArgumentError, "Missing the required parameter 'target_create_azure' when calling V2Api.target_create_azure"
+      # verify the required parameter 'target_create_artifactory' is set
+      if @api_client.config.client_side_validation && target_create_artifactory.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_artifactory' when calling V2Api.target_create_artifactory"
       end
       # resource path
-      local_var_path = '/target-create-azure'
+      local_var_path = '/target-create-artifactory'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -30161,7 +30353,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_azure)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_artifactory)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetCreateOutput'
@@ -30170,7 +30362,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_create_azure",
+        :operation => :"V2Api.target_create_artifactory",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -30181,32 +30373,32 @@ module Akeyless
 
       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: V2Api#target_create_azure\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_create_artifactory\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_create_cloudflare [TargetCreateCloudflare] 
+    # @param target_create_aws [TargetCreateAws] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
-    def target_create_cloudflare(target_create_cloudflare, opts = {})
-      data, _status_code, _headers = target_create_cloudflare_with_http_info(target_create_cloudflare, opts)
+    def target_create_aws(target_create_aws, opts = {})
+      data, _status_code, _headers = target_create_aws_with_http_info(target_create_aws, opts)
       data
     end
 
-    # @param target_create_cloudflare [TargetCreateCloudflare] 
+    # @param target_create_aws [TargetCreateAws] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
-    def target_create_cloudflare_with_http_info(target_create_cloudflare, opts = {})
+    def target_create_aws_with_http_info(target_create_aws, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_create_cloudflare ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_aws ...'
       end
-      # verify the required parameter 'target_create_cloudflare' is set
-      if @api_client.config.client_side_validation && target_create_cloudflare.nil?
-        fail ArgumentError, "Missing the required parameter 'target_create_cloudflare' when calling V2Api.target_create_cloudflare"
+      # verify the required parameter 'target_create_aws' is set
+      if @api_client.config.client_side_validation && target_create_aws.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_aws' when calling V2Api.target_create_aws"
       end
       # resource path
-      local_var_path = '/target-create-cloudflare'
+      local_var_path = '/target-create-aws'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -30225,7 +30417,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_cloudflare)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_aws)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetCreateOutput'
@@ -30234,7 +30426,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_create_cloudflare",
+        :operation => :"V2Api.target_create_aws",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -30245,32 +30437,32 @@ module Akeyless
 
       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: V2Api#target_create_cloudflare\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_create_aws\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_create_db [TargetCreateDB] 
+    # @param target_create_azure [TargetCreateAzure] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
-    def target_create_db(target_create_db, opts = {})
-      data, _status_code, _headers = target_create_db_with_http_info(target_create_db, opts)
+    def target_create_azure(target_create_azure, opts = {})
+      data, _status_code, _headers = target_create_azure_with_http_info(target_create_azure, opts)
       data
     end
 
-    # @param target_create_db [TargetCreateDB] 
+    # @param target_create_azure [TargetCreateAzure] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
-    def target_create_db_with_http_info(target_create_db, opts = {})
+    def target_create_azure_with_http_info(target_create_azure, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_create_db ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_azure ...'
       end
-      # verify the required parameter 'target_create_db' is set
-      if @api_client.config.client_side_validation && target_create_db.nil?
-        fail ArgumentError, "Missing the required parameter 'target_create_db' when calling V2Api.target_create_db"
+      # verify the required parameter 'target_create_azure' is set
+      if @api_client.config.client_side_validation && target_create_azure.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_azure' when calling V2Api.target_create_azure"
       end
       # resource path
-      local_var_path = '/target-create-db'
+      local_var_path = '/target-create-azure'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -30289,7 +30481,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_db)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_azure)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetCreateOutput'
@@ -30298,7 +30490,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_create_db",
+        :operation => :"V2Api.target_create_azure",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -30309,7 +30501,263 @@ module Akeyless
 
       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: V2Api#target_create_db\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_create_azure\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_create_bedrock [TargetCreateBedrock] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_bedrock(target_create_bedrock, opts = {})
+      data, _status_code, _headers = target_create_bedrock_with_http_info(target_create_bedrock, opts)
+      data
+    end
+
+    # @param target_create_bedrock [TargetCreateBedrock] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_bedrock_with_http_info(target_create_bedrock, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_bedrock ...'
+      end
+      # verify the required parameter 'target_create_bedrock' is set
+      if @api_client.config.client_side_validation && target_create_bedrock.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_bedrock' when calling V2Api.target_create_bedrock"
+      end
+      # resource path
+      local_var_path = '/target-create-bedrock'
+
+      # 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(target_create_bedrock)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_create_bedrock",
+        :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: V2Api#target_create_bedrock\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_create_cloudflare [TargetCreateCloudflare] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_cloudflare(target_create_cloudflare, opts = {})
+      data, _status_code, _headers = target_create_cloudflare_with_http_info(target_create_cloudflare, opts)
+      data
+    end
+
+    # @param target_create_cloudflare [TargetCreateCloudflare] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_cloudflare_with_http_info(target_create_cloudflare, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_cloudflare ...'
+      end
+      # verify the required parameter 'target_create_cloudflare' is set
+      if @api_client.config.client_side_validation && target_create_cloudflare.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_cloudflare' when calling V2Api.target_create_cloudflare"
+      end
+      # resource path
+      local_var_path = '/target-create-cloudflare'
+
+      # 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(target_create_cloudflare)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_create_cloudflare",
+        :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: V2Api#target_create_cloudflare\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_create_custom_dns [TargetCreateCustomDns] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_custom_dns(target_create_custom_dns, opts = {})
+      data, _status_code, _headers = target_create_custom_dns_with_http_info(target_create_custom_dns, opts)
+      data
+    end
+
+    # @param target_create_custom_dns [TargetCreateCustomDns] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_custom_dns_with_http_info(target_create_custom_dns, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_custom_dns ...'
+      end
+      # verify the required parameter 'target_create_custom_dns' is set
+      if @api_client.config.client_side_validation && target_create_custom_dns.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_custom_dns' when calling V2Api.target_create_custom_dns"
+      end
+      # resource path
+      local_var_path = '/target-create-custom-dns'
+
+      # 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(target_create_custom_dns)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_create_custom_dns",
+        :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: V2Api#target_create_custom_dns\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_create_db [TargetCreateDB] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_db(target_create_db, opts = {})
+      data, _status_code, _headers = target_create_db_with_http_info(target_create_db, opts)
+      data
+    end
+
+    # @param target_create_db [TargetCreateDB] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_db_with_http_info(target_create_db, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_db ...'
+      end
+      # verify the required parameter 'target_create_db' is set
+      if @api_client.config.client_side_validation && target_create_db.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_db' when calling V2Api.target_create_db"
+      end
+      # resource path
+      local_var_path = '/target-create-db'
+
+      # 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(target_create_db)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_create_db",
+        :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: V2Api#target_create_db\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -31082,6 +31530,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_create_grok [TargetCreateGrok] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_grok(target_create_grok, opts = {})
+      data, _status_code, _headers = target_create_grok_with_http_info(target_create_grok, opts)
+      data
+    end
+
+    # @param target_create_grok [TargetCreateGrok] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_grok_with_http_info(target_create_grok, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_grok ...'
+      end
+      # verify the required parameter 'target_create_grok' is set
+      if @api_client.config.client_side_validation && target_create_grok.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_grok' when calling V2Api.target_create_grok"
+      end
+      # resource path
+      local_var_path = '/target-create-grok'
+
+      # 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(target_create_grok)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_create_grok",
+        :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: V2Api#target_create_grok\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_create_hashi_vault [TargetCreateHashiVault] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
@@ -31210,6 +31722,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_create_keycloak [TargetCreateKeycloak] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_keycloak(target_create_keycloak, opts = {})
+      data, _status_code, _headers = target_create_keycloak_with_http_info(target_create_keycloak, opts)
+      data
+    end
+
+    # @param target_create_keycloak [TargetCreateKeycloak] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_keycloak_with_http_info(target_create_keycloak, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_keycloak ...'
+      end
+      # verify the required parameter 'target_create_keycloak' is set
+      if @api_client.config.client_side_validation && target_create_keycloak.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_keycloak' when calling V2Api.target_create_keycloak"
+      end
+      # resource path
+      local_var_path = '/target-create-keycloak'
+
+      # 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(target_create_keycloak)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_create_keycloak",
+        :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: V2Api#target_create_keycloak\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_create_ldap [TargetCreateLdap] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
@@ -31402,6 +31978,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_create_okta [TargetCreateOkta] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_okta(target_create_okta, opts = {})
+      data, _status_code, _headers = target_create_okta_with_http_info(target_create_okta, opts)
+      data
+    end
+
+    # @param target_create_okta [TargetCreateOkta] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_okta_with_http_info(target_create_okta, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_okta ...'
+      end
+      # verify the required parameter 'target_create_okta' is set
+      if @api_client.config.client_side_validation && target_create_okta.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_okta' when calling V2Api.target_create_okta"
+      end
+      # resource path
+      local_var_path = '/target-create-okta'
+
+      # 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(target_create_okta)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_create_okta",
+        :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: V2Api#target_create_okta\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_create_open_ai [TargetCreateOpenAI] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
@@ -32148,13 +32788,141 @@ module Akeyless
       post_body = opts[:debug_body] || @api_client.object_to_http_body(target_get)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Target'
+      return_type = opts[:debug_return_type] || 'Target'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_get",
+        :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: V2Api#target_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_get_details [TargetGetDetails] 
+    # @param [Hash] opts the optional parameters
+    # @return [GetTargetDetailsOutput]
+    def target_get_details(target_get_details, opts = {})
+      data, _status_code, _headers = target_get_details_with_http_info(target_get_details, opts)
+      data
+    end
+
+    # @param target_get_details [TargetGetDetails] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(GetTargetDetailsOutput, Integer, Hash)>] GetTargetDetailsOutput data, response status code and response headers
+    def target_get_details_with_http_info(target_get_details, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_get_details ...'
+      end
+      # verify the required parameter 'target_get_details' is set
+      if @api_client.config.client_side_validation && target_get_details.nil?
+        fail ArgumentError, "Missing the required parameter 'target_get_details' when calling V2Api.target_get_details"
+      end
+      # resource path
+      local_var_path = '/target-get-details'
+
+      # 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(target_get_details)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'GetTargetDetailsOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_get_details",
+        :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: V2Api#target_get_details\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_list [TargetList] 
+    # @param [Hash] opts the optional parameters
+    # @return [ListTargetsOutput]
+    def target_list(target_list, opts = {})
+      data, _status_code, _headers = target_list_with_http_info(target_list, opts)
+      data
+    end
+
+    # @param target_list [TargetList] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(ListTargetsOutput, Integer, Hash)>] ListTargetsOutput data, response status code and response headers
+    def target_list_with_http_info(target_list, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_list ...'
+      end
+      # verify the required parameter 'target_list' is set
+      if @api_client.config.client_side_validation && target_list.nil?
+        fail ArgumentError, "Missing the required parameter 'target_list' when calling V2Api.target_list"
+      end
+      # resource path
+      local_var_path = '/target-list'
+
+      # 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(target_list)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListTargetsOutput'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_get",
+        :operation => :"V2Api.target_list",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -32165,32 +32933,32 @@ module Akeyless
 
       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: V2Api#target_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_get_details [TargetGetDetails] 
+    # @param target_update_aerospike [TargetUpdateAerospike] 
     # @param [Hash] opts the optional parameters
-    # @return [GetTargetDetailsOutput]
-    def target_get_details(target_get_details, opts = {})
-      data, _status_code, _headers = target_get_details_with_http_info(target_get_details, opts)
+    # @return [TargetUpdateOutput]
+    def target_update_aerospike(target_update_aerospike, opts = {})
+      data, _status_code, _headers = target_update_aerospike_with_http_info(target_update_aerospike, opts)
       data
     end
 
-    # @param target_get_details [TargetGetDetails] 
+    # @param target_update_aerospike [TargetUpdateAerospike] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(GetTargetDetailsOutput, Integer, Hash)>] GetTargetDetailsOutput data, response status code and response headers
-    def target_get_details_with_http_info(target_get_details, opts = {})
+    # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
+    def target_update_aerospike_with_http_info(target_update_aerospike, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_get_details ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_aerospike ...'
       end
-      # verify the required parameter 'target_get_details' is set
-      if @api_client.config.client_side_validation && target_get_details.nil?
-        fail ArgumentError, "Missing the required parameter 'target_get_details' when calling V2Api.target_get_details"
+      # verify the required parameter 'target_update_aerospike' is set
+      if @api_client.config.client_side_validation && target_update_aerospike.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_aerospike' when calling V2Api.target_update_aerospike"
       end
       # resource path
-      local_var_path = '/target-get-details'
+      local_var_path = '/target-update-aerospike'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -32209,16 +32977,16 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_get_details)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_aerospike)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'GetTargetDetailsOutput'
+      return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_get_details",
+        :operation => :"V2Api.target_update_aerospike",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -32229,32 +32997,32 @@ module Akeyless
 
       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: V2Api#target_get_details\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_update_aerospike\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_list [TargetList] 
+    # @param target_update_anthropic [TargetUpdateAnthropic] 
     # @param [Hash] opts the optional parameters
-    # @return [ListTargetsOutput]
-    def target_list(target_list, opts = {})
-      data, _status_code, _headers = target_list_with_http_info(target_list, opts)
+    # @return [TargetUpdateOutput]
+    def target_update_anthropic(target_update_anthropic, opts = {})
+      data, _status_code, _headers = target_update_anthropic_with_http_info(target_update_anthropic, opts)
       data
     end
 
-    # @param target_list [TargetList] 
+    # @param target_update_anthropic [TargetUpdateAnthropic] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(ListTargetsOutput, Integer, Hash)>] ListTargetsOutput data, response status code and response headers
-    def target_list_with_http_info(target_list, opts = {})
+    # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
+    def target_update_anthropic_with_http_info(target_update_anthropic, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_list ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_anthropic ...'
       end
-      # verify the required parameter 'target_list' is set
-      if @api_client.config.client_side_validation && target_list.nil?
-        fail ArgumentError, "Missing the required parameter 'target_list' when calling V2Api.target_list"
+      # verify the required parameter 'target_update_anthropic' is set
+      if @api_client.config.client_side_validation && target_update_anthropic.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_anthropic' when calling V2Api.target_update_anthropic"
       end
       # resource path
-      local_var_path = '/target-list'
+      local_var_path = '/target-update-anthropic'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -32273,16 +33041,16 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_list)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_anthropic)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'ListTargetsOutput'
+      return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_list",
+        :operation => :"V2Api.target_update_anthropic",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -32293,7 +33061,7 @@ module Akeyless
 
       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: V2Api#target_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_update_anthropic\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -32490,6 +33258,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_update_bedrock [TargetUpdateBedrock] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetUpdateOutput]
+    def target_update_bedrock(target_update_bedrock, opts = {})
+      data, _status_code, _headers = target_update_bedrock_with_http_info(target_update_bedrock, opts)
+      data
+    end
+
+    # @param target_update_bedrock [TargetUpdateBedrock] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
+    def target_update_bedrock_with_http_info(target_update_bedrock, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_bedrock ...'
+      end
+      # verify the required parameter 'target_update_bedrock' is set
+      if @api_client.config.client_side_validation && target_update_bedrock.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_bedrock' when calling V2Api.target_update_bedrock"
+      end
+      # resource path
+      local_var_path = '/target-update-bedrock'
+
+      # 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(target_update_bedrock)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_update_bedrock",
+        :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: V2Api#target_update_bedrock\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_update_cloudflare [TargetUpdateCloudflare] 
     # @param [Hash] opts the optional parameters
     # @return [TargetUpdateOutput]
@@ -32554,6 +33386,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_update_custom_dns [TargetUpdateCustomDns] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetUpdateOutput]
+    def target_update_custom_dns(target_update_custom_dns, opts = {})
+      data, _status_code, _headers = target_update_custom_dns_with_http_info(target_update_custom_dns, opts)
+      data
+    end
+
+    # @param target_update_custom_dns [TargetUpdateCustomDns] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
+    def target_update_custom_dns_with_http_info(target_update_custom_dns, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_custom_dns ...'
+      end
+      # verify the required parameter 'target_update_custom_dns' is set
+      if @api_client.config.client_side_validation && target_update_custom_dns.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_custom_dns' when calling V2Api.target_update_custom_dns"
+      end
+      # resource path
+      local_var_path = '/target-update-custom-dns'
+
+      # 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(target_update_custom_dns)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_update_custom_dns",
+        :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: V2Api#target_update_custom_dns\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_update_db [TargetUpdateDB] 
     # @param [Hash] opts the optional parameters
     # @return [TargetUpdateOutput]
@@ -33342,7 +34238,135 @@ module Akeyless
         fail ArgumentError, "Missing the required parameter 'target_update_google_trust' when calling V2Api.target_update_google_trust"
       end
       # resource path
-      local_var_path = '/target-update-google-trust'
+      local_var_path = '/target-update-google-trust'
+
+      # 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(target_update_google_trust)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_update_google_trust",
+        :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: V2Api#target_update_google_trust\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_update_grok [TargetUpdateGrok] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetUpdateOutput]
+    def target_update_grok(target_update_grok, opts = {})
+      data, _status_code, _headers = target_update_grok_with_http_info(target_update_grok, opts)
+      data
+    end
+
+    # @param target_update_grok [TargetUpdateGrok] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
+    def target_update_grok_with_http_info(target_update_grok, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_grok ...'
+      end
+      # verify the required parameter 'target_update_grok' is set
+      if @api_client.config.client_side_validation && target_update_grok.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_grok' when calling V2Api.target_update_grok"
+      end
+      # resource path
+      local_var_path = '/target-update-grok'
+
+      # 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(target_update_grok)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_update_grok",
+        :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: V2Api#target_update_grok\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param target_update_hashi_vault [TargetUpdateHashiVault] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetUpdateOutput]
+    def target_update_hashi_vault(target_update_hashi_vault, opts = {})
+      data, _status_code, _headers = target_update_hashi_vault_with_http_info(target_update_hashi_vault, opts)
+      data
+    end
+
+    # @param target_update_hashi_vault [TargetUpdateHashiVault] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
+    def target_update_hashi_vault_with_http_info(target_update_hashi_vault, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_hashi_vault ...'
+      end
+      # verify the required parameter 'target_update_hashi_vault' is set
+      if @api_client.config.client_side_validation && target_update_hashi_vault.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_hashi_vault' when calling V2Api.target_update_hashi_vault"
+      end
+      # resource path
+      local_var_path = '/target-update-hashi-vault'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -33361,7 +34385,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_google_trust)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_hashi_vault)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
@@ -33370,7 +34394,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_update_google_trust",
+        :operation => :"V2Api.target_update_hashi_vault",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -33381,32 +34405,32 @@ module Akeyless
 
       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: V2Api#target_update_google_trust\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_update_hashi_vault\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_update_hashi_vault [TargetUpdateHashiVault] 
+    # @param target_update_k8s [TargetUpdateK8s] 
     # @param [Hash] opts the optional parameters
     # @return [TargetUpdateOutput]
-    def target_update_hashi_vault(target_update_hashi_vault, opts = {})
-      data, _status_code, _headers = target_update_hashi_vault_with_http_info(target_update_hashi_vault, opts)
+    def target_update_k8s(target_update_k8s, opts = {})
+      data, _status_code, _headers = target_update_k8s_with_http_info(target_update_k8s, opts)
       data
     end
 
-    # @param target_update_hashi_vault [TargetUpdateHashiVault] 
+    # @param target_update_k8s [TargetUpdateK8s] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
-    def target_update_hashi_vault_with_http_info(target_update_hashi_vault, opts = {})
+    def target_update_k8s_with_http_info(target_update_k8s, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_update_hashi_vault ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_k8s ...'
       end
-      # verify the required parameter 'target_update_hashi_vault' is set
-      if @api_client.config.client_side_validation && target_update_hashi_vault.nil?
-        fail ArgumentError, "Missing the required parameter 'target_update_hashi_vault' when calling V2Api.target_update_hashi_vault"
+      # verify the required parameter 'target_update_k8s' is set
+      if @api_client.config.client_side_validation && target_update_k8s.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_k8s' when calling V2Api.target_update_k8s"
       end
       # resource path
-      local_var_path = '/target-update-hashi-vault'
+      local_var_path = '/target-update-k8s'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -33425,7 +34449,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_hashi_vault)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_k8s)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
@@ -33434,7 +34458,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_update_hashi_vault",
+        :operation => :"V2Api.target_update_k8s",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -33445,32 +34469,32 @@ module Akeyless
 
       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: V2Api#target_update_hashi_vault\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_update_k8s\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_update_k8s [TargetUpdateK8s] 
+    # @param target_update_keycloak [TargetUpdateKeycloak] 
     # @param [Hash] opts the optional parameters
     # @return [TargetUpdateOutput]
-    def target_update_k8s(target_update_k8s, opts = {})
-      data, _status_code, _headers = target_update_k8s_with_http_info(target_update_k8s, opts)
+    def target_update_keycloak(target_update_keycloak, opts = {})
+      data, _status_code, _headers = target_update_keycloak_with_http_info(target_update_keycloak, opts)
       data
     end
 
-    # @param target_update_k8s [TargetUpdateK8s] 
+    # @param target_update_keycloak [TargetUpdateKeycloak] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
-    def target_update_k8s_with_http_info(target_update_k8s, opts = {})
+    def target_update_keycloak_with_http_info(target_update_keycloak, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_update_k8s ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_keycloak ...'
       end
-      # verify the required parameter 'target_update_k8s' is set
-      if @api_client.config.client_side_validation && target_update_k8s.nil?
-        fail ArgumentError, "Missing the required parameter 'target_update_k8s' when calling V2Api.target_update_k8s"
+      # verify the required parameter 'target_update_keycloak' is set
+      if @api_client.config.client_side_validation && target_update_keycloak.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_keycloak' when calling V2Api.target_update_keycloak"
       end
       # resource path
-      local_var_path = '/target-update-k8s'
+      local_var_path = '/target-update-keycloak'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -33489,7 +34513,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_k8s)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_keycloak)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
@@ -33498,7 +34522,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_update_k8s",
+        :operation => :"V2Api.target_update_keycloak",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -33509,7 +34533,7 @@ module Akeyless
 
       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: V2Api#target_update_k8s\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_update_keycloak\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -33706,6 +34730,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_update_okta [TargetUpdateOkta] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetUpdateOutput]
+    def target_update_okta(target_update_okta, opts = {})
+      data, _status_code, _headers = target_update_okta_with_http_info(target_update_okta, opts)
+      data
+    end
+
+    # @param target_update_okta [TargetUpdateOkta] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetUpdateOutput, Integer, Hash)>] TargetUpdateOutput data, response status code and response headers
+    def target_update_okta_with_http_info(target_update_okta, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_update_okta ...'
+      end
+      # verify the required parameter 'target_update_okta' is set
+      if @api_client.config.client_side_validation && target_update_okta.nil?
+        fail ArgumentError, "Missing the required parameter 'target_update_okta' when calling V2Api.target_update_okta"
+      end
+      # resource path
+      local_var_path = '/target-update-okta'
+
+      # 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(target_update_okta)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.target_update_okta",
+        :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: V2Api#target_update_okta\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_update_open_ai [TargetUpdateOpenAI] 
     # @param [Hash] opts the optional parameters
     # @return [TargetUpdateOutput]
@@ -37354,6 +38442,198 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param update_mcp_secret_bearer_token [UpdateMcpSecretBearerToken] 
+    # @param [Hash] opts the optional parameters
+    # @return [UpdateSecretValOutput]
+    def update_mcp_secret_bearer_token(update_mcp_secret_bearer_token, opts = {})
+      data, _status_code, _headers = update_mcp_secret_bearer_token_with_http_info(update_mcp_secret_bearer_token, opts)
+      data
+    end
+
+    # @param update_mcp_secret_bearer_token [UpdateMcpSecretBearerToken] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(UpdateSecretValOutput, Integer, Hash)>] UpdateSecretValOutput data, response status code and response headers
+    def update_mcp_secret_bearer_token_with_http_info(update_mcp_secret_bearer_token, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.update_mcp_secret_bearer_token ...'
+      end
+      # verify the required parameter 'update_mcp_secret_bearer_token' is set
+      if @api_client.config.client_side_validation && update_mcp_secret_bearer_token.nil?
+        fail ArgumentError, "Missing the required parameter 'update_mcp_secret_bearer_token' when calling V2Api.update_mcp_secret_bearer_token"
+      end
+      # resource path
+      local_var_path = '/update-mcp-secret-bearer-token'
+
+      # 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_mcp_secret_bearer_token)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'UpdateSecretValOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.update_mcp_secret_bearer_token",
+        :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: V2Api#update_mcp_secret_bearer_token\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param update_mcp_secret_o_auth_auth_code [UpdateMcpSecretOAuthAuthCode] 
+    # @param [Hash] opts the optional parameters
+    # @return [UpdateSecretValOutput]
+    def update_mcp_secret_o_auth_auth_code(update_mcp_secret_o_auth_auth_code, opts = {})
+      data, _status_code, _headers = update_mcp_secret_o_auth_auth_code_with_http_info(update_mcp_secret_o_auth_auth_code, opts)
+      data
+    end
+
+    # @param update_mcp_secret_o_auth_auth_code [UpdateMcpSecretOAuthAuthCode] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(UpdateSecretValOutput, Integer, Hash)>] UpdateSecretValOutput data, response status code and response headers
+    def update_mcp_secret_o_auth_auth_code_with_http_info(update_mcp_secret_o_auth_auth_code, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.update_mcp_secret_o_auth_auth_code ...'
+      end
+      # verify the required parameter 'update_mcp_secret_o_auth_auth_code' is set
+      if @api_client.config.client_side_validation && update_mcp_secret_o_auth_auth_code.nil?
+        fail ArgumentError, "Missing the required parameter 'update_mcp_secret_o_auth_auth_code' when calling V2Api.update_mcp_secret_o_auth_auth_code"
+      end
+      # resource path
+      local_var_path = '/update-mcp-secret-oauth-authorization-code'
+
+      # 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_mcp_secret_o_auth_auth_code)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'UpdateSecretValOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.update_mcp_secret_o_auth_auth_code",
+        :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: V2Api#update_mcp_secret_o_auth_auth_code\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param update_mcp_secret_o_auth_client_creds [UpdateMcpSecretOAuthClientCreds] 
+    # @param [Hash] opts the optional parameters
+    # @return [UpdateSecretValOutput]
+    def update_mcp_secret_o_auth_client_creds(update_mcp_secret_o_auth_client_creds, opts = {})
+      data, _status_code, _headers = update_mcp_secret_o_auth_client_creds_with_http_info(update_mcp_secret_o_auth_client_creds, opts)
+      data
+    end
+
+    # @param update_mcp_secret_o_auth_client_creds [UpdateMcpSecretOAuthClientCreds] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(UpdateSecretValOutput, Integer, Hash)>] UpdateSecretValOutput data, response status code and response headers
+    def update_mcp_secret_o_auth_client_creds_with_http_info(update_mcp_secret_o_auth_client_creds, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.update_mcp_secret_o_auth_client_creds ...'
+      end
+      # verify the required parameter 'update_mcp_secret_o_auth_client_creds' is set
+      if @api_client.config.client_side_validation && update_mcp_secret_o_auth_client_creds.nil?
+        fail ArgumentError, "Missing the required parameter 'update_mcp_secret_o_auth_client_creds' when calling V2Api.update_mcp_secret_o_auth_client_creds"
+      end
+      # resource path
+      local_var_path = '/update-mcp-secret-oauth-client-credentials'
+
+      # 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_mcp_secret_o_auth_client_creds)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'UpdateSecretValOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.update_mcp_secret_o_auth_client_creds",
+        :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: V2Api#update_mcp_secret_o_auth_client_creds\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param update_native_k8_s_target [UpdateNativeK8STarget] 
     # @param [Hash] opts the optional parameters
     # @return [UpdateNativeK8STargetOutput]