akeyless 5.0.27 → 5.0.30

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]
@@ -13911,27 +14103,27 @@ module Akeyless
       return data, status_code, headers
     end
 
-    # @param folder_get [FolderGet] 
+    # @param folder_delete_sync [FolderDeleteSync] 
     # @param [Hash] opts the optional parameters
-    # @return [FolderGetOutput]
-    def folder_get(folder_get, opts = {})
-      data, _status_code, _headers = folder_get_with_http_info(folder_get, opts)
+    # @return [FolderDeleteSyncOutput]
+    def folder_delete_sync(folder_delete_sync, opts = {})
+      data, _status_code, _headers = folder_delete_sync_with_http_info(folder_delete_sync, opts)
       data
     end
 
-    # @param folder_get [FolderGet] 
+    # @param folder_delete_sync [FolderDeleteSync] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(FolderGetOutput, Integer, Hash)>] FolderGetOutput data, response status code and response headers
-    def folder_get_with_http_info(folder_get, opts = {})
+    # @return [Array<(FolderDeleteSyncOutput, Integer, Hash)>] FolderDeleteSyncOutput data, response status code and response headers
+    def folder_delete_sync_with_http_info(folder_delete_sync, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.folder_get ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.folder_delete_sync ...'
       end
-      # verify the required parameter 'folder_get' is set
-      if @api_client.config.client_side_validation && folder_get.nil?
-        fail ArgumentError, "Missing the required parameter 'folder_get' when calling V2Api.folder_get"
+      # verify the required parameter 'folder_delete_sync' is set
+      if @api_client.config.client_side_validation && folder_delete_sync.nil?
+        fail ArgumentError, "Missing the required parameter 'folder_delete_sync' when calling V2Api.folder_delete_sync"
       end
       # resource path
-      local_var_path = '/folder-get'
+      local_var_path = '/folder-delete-sync'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -13950,16 +14142,16 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(folder_get)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(folder_delete_sync)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'FolderGetOutput'
+      return_type = opts[:debug_return_type] || 'FolderDeleteSyncOutput'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.folder_get",
+        :operation => :"V2Api.folder_delete_sync",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -13970,32 +14162,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#folder_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#folder_delete_sync\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param folder_update [FolderUpdate] 
+    # @param folder_get [FolderGet] 
     # @param [Hash] opts the optional parameters
-    # @return [Object]
-    def folder_update(folder_update, opts = {})
-      data, _status_code, _headers = folder_update_with_http_info(folder_update, opts)
+    # @return [FolderGetOutput]
+    def folder_get(folder_get, opts = {})
+      data, _status_code, _headers = folder_get_with_http_info(folder_get, opts)
       data
     end
 
-    # @param folder_update [FolderUpdate] 
+    # @param folder_get [FolderGet] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(Object, Integer, Hash)>] Object data, response status code and response headers
-    def folder_update_with_http_info(folder_update, opts = {})
+    # @return [Array<(FolderGetOutput, Integer, Hash)>] FolderGetOutput data, response status code and response headers
+    def folder_get_with_http_info(folder_get, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.folder_update ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.folder_get ...'
       end
-      # verify the required parameter 'folder_update' is set
-      if @api_client.config.client_side_validation && folder_update.nil?
-        fail ArgumentError, "Missing the required parameter 'folder_update' when calling V2Api.folder_update"
+      # verify the required parameter 'folder_get' is set
+      if @api_client.config.client_side_validation && folder_get.nil?
+        fail ArgumentError, "Missing the required parameter 'folder_get' when calling V2Api.folder_get"
       end
       # resource path
-      local_var_path = '/folder-update'
+      local_var_path = '/folder-get'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -14014,16 +14206,16 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(folder_update)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(folder_get)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Object'
+      return_type = opts[:debug_return_type] || 'FolderGetOutput'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.folder_update",
+        :operation => :"V2Api.folder_get",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -14034,32 +14226,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#folder_update\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#folder_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param gateway_create_allowed_access [GatewayCreateAllowedAccess] 
+    # @param folder_sync [FolderSync] 
     # @param [Hash] opts the optional parameters
-    # @return [AllowedAccess]
-    def gateway_create_allowed_access(gateway_create_allowed_access, opts = {})
-      data, _status_code, _headers = gateway_create_allowed_access_with_http_info(gateway_create_allowed_access, opts)
+    # @return [FolderSyncOutput]
+    def folder_sync(folder_sync, opts = {})
+      data, _status_code, _headers = folder_sync_with_http_info(folder_sync, opts)
       data
     end
 
-    # @param gateway_create_allowed_access [GatewayCreateAllowedAccess] 
+    # @param folder_sync [FolderSync] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(AllowedAccess, Integer, Hash)>] AllowedAccess data, response status code and response headers
-    def gateway_create_allowed_access_with_http_info(gateway_create_allowed_access, opts = {})
+    # @return [Array<(FolderSyncOutput, Integer, Hash)>] FolderSyncOutput data, response status code and response headers
+    def folder_sync_with_http_info(folder_sync, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.gateway_create_allowed_access ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.folder_sync ...'
       end
-      # verify the required parameter 'gateway_create_allowed_access' is set
-      if @api_client.config.client_side_validation && gateway_create_allowed_access.nil?
-        fail ArgumentError, "Missing the required parameter 'gateway_create_allowed_access' when calling V2Api.gateway_create_allowed_access"
+      # verify the required parameter 'folder_sync' is set
+      if @api_client.config.client_side_validation && folder_sync.nil?
+        fail ArgumentError, "Missing the required parameter 'folder_sync' when calling V2Api.folder_sync"
       end
       # resource path
-      local_var_path = '/gateway-create-allowed-access'
+      local_var_path = '/folder-sync'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -14078,16 +14270,16 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(gateway_create_allowed_access)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(folder_sync)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'AllowedAccess'
+      return_type = opts[:debug_return_type] || 'FolderSyncOutput'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.gateway_create_allowed_access",
+        :operation => :"V2Api.folder_sync",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -14098,32 +14290,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#gateway_create_allowed_access\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#folder_sync\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param gateway_create_k8_s_auth_config [GatewayCreateK8SAuthConfig] 
+    # @param folder_sync_all [FolderSyncAll] 
     # @param [Hash] opts the optional parameters
-    # @return [GatewayCreateK8SAuthConfigOutput]
-    def gateway_create_k8_s_auth_config(gateway_create_k8_s_auth_config, opts = {})
-      data, _status_code, _headers = gateway_create_k8_s_auth_config_with_http_info(gateway_create_k8_s_auth_config, opts)
+    # @return [FolderSyncAllOutput]
+    def folder_sync_all(folder_sync_all, opts = {})
+      data, _status_code, _headers = folder_sync_all_with_http_info(folder_sync_all, opts)
       data
     end
 
-    # @param gateway_create_k8_s_auth_config [GatewayCreateK8SAuthConfig] 
+    # @param folder_sync_all [FolderSyncAll] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(GatewayCreateK8SAuthConfigOutput, Integer, Hash)>] GatewayCreateK8SAuthConfigOutput data, response status code and response headers
-    def gateway_create_k8_s_auth_config_with_http_info(gateway_create_k8_s_auth_config, opts = {})
+    # @return [Array<(FolderSyncAllOutput, Integer, Hash)>] FolderSyncAllOutput data, response status code and response headers
+    def folder_sync_all_with_http_info(folder_sync_all, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.gateway_create_k8_s_auth_config ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.folder_sync_all ...'
       end
-      # verify the required parameter 'gateway_create_k8_s_auth_config' is set
-      if @api_client.config.client_side_validation && gateway_create_k8_s_auth_config.nil?
-        fail ArgumentError, "Missing the required parameter 'gateway_create_k8_s_auth_config' when calling V2Api.gateway_create_k8_s_auth_config"
+      # verify the required parameter 'folder_sync_all' is set
+      if @api_client.config.client_side_validation && folder_sync_all.nil?
+        fail ArgumentError, "Missing the required parameter 'folder_sync_all' when calling V2Api.folder_sync_all"
       end
       # resource path
-      local_var_path = '/gateway-create-k8s-auth-config'
+      local_var_path = '/folder-sync-all'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -14142,16 +14334,16 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(gateway_create_k8_s_auth_config)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(folder_sync_all)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'GatewayCreateK8SAuthConfigOutput'
+      return_type = opts[:debug_return_type] || 'FolderSyncAllOutput'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.gateway_create_k8_s_auth_config",
+        :operation => :"V2Api.folder_sync_all",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -14162,32 +14354,224 @@ 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#gateway_create_k8_s_auth_config\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#folder_sync_all\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param gateway_create_migration [GatewayCreateMigration] 
+    # @param folder_update [FolderUpdate] 
     # @param [Hash] opts the optional parameters
-    # @return [GatewayMigrationCreateOutput]
-    def gateway_create_migration(gateway_create_migration, opts = {})
-      data, _status_code, _headers = gateway_create_migration_with_http_info(gateway_create_migration, opts)
+    # @return [Object]
+    def folder_update(folder_update, opts = {})
+      data, _status_code, _headers = folder_update_with_http_info(folder_update, opts)
       data
     end
 
-    # @param gateway_create_migration [GatewayCreateMigration] 
+    # @param folder_update [FolderUpdate] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(GatewayMigrationCreateOutput, Integer, Hash)>] GatewayMigrationCreateOutput data, response status code and response headers
-    def gateway_create_migration_with_http_info(gateway_create_migration, opts = {})
+    # @return [Array<(Object, Integer, Hash)>] Object data, response status code and response headers
+    def folder_update_with_http_info(folder_update, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.gateway_create_migration ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.folder_update ...'
       end
-      # verify the required parameter 'gateway_create_migration' is set
-      if @api_client.config.client_side_validation && gateway_create_migration.nil?
-        fail ArgumentError, "Missing the required parameter 'gateway_create_migration' when calling V2Api.gateway_create_migration"
+      # verify the required parameter 'folder_update' is set
+      if @api_client.config.client_side_validation && folder_update.nil?
+        fail ArgumentError, "Missing the required parameter 'folder_update' when calling V2Api.folder_update"
       end
       # resource path
-      local_var_path = '/gateway-create-migration'
+      local_var_path = '/folder-update'
+
+      # 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(folder_update)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'Object'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.folder_update",
+        :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#folder_update\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param gateway_create_allowed_access [GatewayCreateAllowedAccess] 
+    # @param [Hash] opts the optional parameters
+    # @return [AllowedAccess]
+    def gateway_create_allowed_access(gateway_create_allowed_access, opts = {})
+      data, _status_code, _headers = gateway_create_allowed_access_with_http_info(gateway_create_allowed_access, opts)
+      data
+    end
+
+    # @param gateway_create_allowed_access [GatewayCreateAllowedAccess] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(AllowedAccess, Integer, Hash)>] AllowedAccess data, response status code and response headers
+    def gateway_create_allowed_access_with_http_info(gateway_create_allowed_access, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.gateway_create_allowed_access ...'
+      end
+      # verify the required parameter 'gateway_create_allowed_access' is set
+      if @api_client.config.client_side_validation && gateway_create_allowed_access.nil?
+        fail ArgumentError, "Missing the required parameter 'gateway_create_allowed_access' when calling V2Api.gateway_create_allowed_access"
+      end
+      # resource path
+      local_var_path = '/gateway-create-allowed-access'
+
+      # 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(gateway_create_allowed_access)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'AllowedAccess'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.gateway_create_allowed_access",
+        :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#gateway_create_allowed_access\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param gateway_create_k8_s_auth_config [GatewayCreateK8SAuthConfig] 
+    # @param [Hash] opts the optional parameters
+    # @return [GatewayCreateK8SAuthConfigOutput]
+    def gateway_create_k8_s_auth_config(gateway_create_k8_s_auth_config, opts = {})
+      data, _status_code, _headers = gateway_create_k8_s_auth_config_with_http_info(gateway_create_k8_s_auth_config, opts)
+      data
+    end
+
+    # @param gateway_create_k8_s_auth_config [GatewayCreateK8SAuthConfig] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(GatewayCreateK8SAuthConfigOutput, Integer, Hash)>] GatewayCreateK8SAuthConfigOutput data, response status code and response headers
+    def gateway_create_k8_s_auth_config_with_http_info(gateway_create_k8_s_auth_config, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.gateway_create_k8_s_auth_config ...'
+      end
+      # verify the required parameter 'gateway_create_k8_s_auth_config' is set
+      if @api_client.config.client_side_validation && gateway_create_k8_s_auth_config.nil?
+        fail ArgumentError, "Missing the required parameter 'gateway_create_k8_s_auth_config' when calling V2Api.gateway_create_k8_s_auth_config"
+      end
+      # resource path
+      local_var_path = '/gateway-create-k8s-auth-config'
+
+      # 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(gateway_create_k8_s_auth_config)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'GatewayCreateK8SAuthConfigOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.gateway_create_k8_s_auth_config",
+        :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#gateway_create_k8_s_auth_config\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param gateway_create_migration [GatewayCreateMigration] 
+    # @param [Hash] opts the optional parameters
+    # @return [GatewayMigrationCreateOutput]
+    def gateway_create_migration(gateway_create_migration, opts = {})
+      data, _status_code, _headers = gateway_create_migration_with_http_info(gateway_create_migration, opts)
+      data
+    end
+
+    # @param gateway_create_migration [GatewayCreateMigration] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(GatewayMigrationCreateOutput, Integer, Hash)>] GatewayMigrationCreateOutput data, response status code and response headers
+    def gateway_create_migration_with_http_info(gateway_create_migration, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.gateway_create_migration ...'
+      end
+      # verify the required parameter 'gateway_create_migration' is set
+      if @api_client.config.client_side_validation && gateway_create_migration.nil?
+        fail ArgumentError, "Missing the required parameter 'gateway_create_migration' when calling V2Api.gateway_create_migration"
+      end
+      # resource path
+      local_var_path = '/gateway-create-migration'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -26346,6 +26730,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param rotated_secret_create_hashi_vault [RotatedSecretCreateHashiVault] 
+    # @param [Hash] opts the optional parameters
+    # @return [RotatedSecretCreateOutput]
+    def rotated_secret_create_hashi_vault(rotated_secret_create_hashi_vault, opts = {})
+      data, _status_code, _headers = rotated_secret_create_hashi_vault_with_http_info(rotated_secret_create_hashi_vault, opts)
+      data
+    end
+
+    # @param rotated_secret_create_hashi_vault [RotatedSecretCreateHashiVault] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(RotatedSecretCreateOutput, Integer, Hash)>] RotatedSecretCreateOutput data, response status code and response headers
+    def rotated_secret_create_hashi_vault_with_http_info(rotated_secret_create_hashi_vault, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.rotated_secret_create_hashi_vault ...'
+      end
+      # verify the required parameter 'rotated_secret_create_hashi_vault' is set
+      if @api_client.config.client_side_validation && rotated_secret_create_hashi_vault.nil?
+        fail ArgumentError, "Missing the required parameter 'rotated_secret_create_hashi_vault' when calling V2Api.rotated_secret_create_hashi_vault"
+      end
+      # resource path
+      local_var_path = '/rotated-secret-create-hashi-vault'
+
+      # 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(rotated_secret_create_hashi_vault)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'RotatedSecretCreateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.rotated_secret_create_hashi_vault",
+        :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#rotated_secret_create_hashi_vault\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param rotated_secret_create_ldap [RotatedSecretCreateLdap] 
     # @param [Hash] opts the optional parameters
     # @return [RotatedSecretCreateOutput]
@@ -27946,27 +28394,27 @@ module Akeyless
       return data, status_code, headers
     end
 
-    # @param rotated_secret_update_ldap [RotatedSecretUpdateLdap] 
+    # @param rotated_secret_update_hashi_vault [RotatedSecretUpdateHashiVault] 
     # @param [Hash] opts the optional parameters
     # @return [RotatedSecretUpdateOutput]
-    def rotated_secret_update_ldap(rotated_secret_update_ldap, opts = {})
-      data, _status_code, _headers = rotated_secret_update_ldap_with_http_info(rotated_secret_update_ldap, opts)
+    def rotated_secret_update_hashi_vault(rotated_secret_update_hashi_vault, opts = {})
+      data, _status_code, _headers = rotated_secret_update_hashi_vault_with_http_info(rotated_secret_update_hashi_vault, opts)
       data
     end
 
-    # @param rotated_secret_update_ldap [RotatedSecretUpdateLdap] 
+    # @param rotated_secret_update_hashi_vault [RotatedSecretUpdateHashiVault] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(RotatedSecretUpdateOutput, Integer, Hash)>] RotatedSecretUpdateOutput data, response status code and response headers
-    def rotated_secret_update_ldap_with_http_info(rotated_secret_update_ldap, opts = {})
+    def rotated_secret_update_hashi_vault_with_http_info(rotated_secret_update_hashi_vault, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.rotated_secret_update_ldap ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.rotated_secret_update_hashi_vault ...'
       end
-      # verify the required parameter 'rotated_secret_update_ldap' is set
-      if @api_client.config.client_side_validation && rotated_secret_update_ldap.nil?
-        fail ArgumentError, "Missing the required parameter 'rotated_secret_update_ldap' when calling V2Api.rotated_secret_update_ldap"
+      # verify the required parameter 'rotated_secret_update_hashi_vault' is set
+      if @api_client.config.client_side_validation && rotated_secret_update_hashi_vault.nil?
+        fail ArgumentError, "Missing the required parameter 'rotated_secret_update_hashi_vault' when calling V2Api.rotated_secret_update_hashi_vault"
       end
       # resource path
-      local_var_path = '/rotated-secret-update-ldap'
+      local_var_path = '/rotated-secret-update-hashi-vault'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -27985,7 +28433,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(rotated_secret_update_ldap)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(rotated_secret_update_hashi_vault)
 
       # return_type
       return_type = opts[:debug_return_type] || 'RotatedSecretUpdateOutput'
@@ -27994,7 +28442,71 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.rotated_secret_update_ldap",
+        :operation => :"V2Api.rotated_secret_update_hashi_vault",
+        :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#rotated_secret_update_hashi_vault\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param rotated_secret_update_ldap [RotatedSecretUpdateLdap] 
+    # @param [Hash] opts the optional parameters
+    # @return [RotatedSecretUpdateOutput]
+    def rotated_secret_update_ldap(rotated_secret_update_ldap, opts = {})
+      data, _status_code, _headers = rotated_secret_update_ldap_with_http_info(rotated_secret_update_ldap, opts)
+      data
+    end
+
+    # @param rotated_secret_update_ldap [RotatedSecretUpdateLdap] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(RotatedSecretUpdateOutput, Integer, Hash)>] RotatedSecretUpdateOutput data, response status code and response headers
+    def rotated_secret_update_ldap_with_http_info(rotated_secret_update_ldap, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.rotated_secret_update_ldap ...'
+      end
+      # verify the required parameter 'rotated_secret_update_ldap' is set
+      if @api_client.config.client_side_validation && rotated_secret_update_ldap.nil?
+        fail ArgumentError, "Missing the required parameter 'rotated_secret_update_ldap' when calling V2Api.rotated_secret_update_ldap"
+      end
+      # resource path
+      local_var_path = '/rotated-secret-update-ldap'
+
+      # 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(rotated_secret_update_ldap)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'RotatedSecretUpdateOutput'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"V2Api.rotated_secret_update_ldap",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -29674,6 +30186,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_create_anthropic [TargetCreateAnthropic] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    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_anthropic [TargetCreateAnthropic] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    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_anthropic ...'
+      end
+      # 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-anthropic'
+
+      # 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_anthropic)
+
+      # 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_anthropic",
+        :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_anthropic\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_create_artifactory [TargetCreateArtifactory] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
@@ -29866,6 +30442,70 @@ module Akeyless
       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]
@@ -29930,6 +30570,70 @@ module Akeyless
       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]
@@ -30762,27 +31466,27 @@ module Akeyless
       return data, status_code, headers
     end
 
-    # @param target_create_hashi_vault [TargetCreateHashiVault] 
+    # @param target_create_grok [TargetCreateGrok] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
-    def target_create_hashi_vault(target_create_hashi_vault, opts = {})
-      data, _status_code, _headers = target_create_hashi_vault_with_http_info(target_create_hashi_vault, opts)
+    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_hashi_vault [TargetCreateHashiVault] 
+    # @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_hashi_vault_with_http_info(target_create_hashi_vault, opts = {})
+    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_hashi_vault ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_grok ...'
       end
-      # verify the required parameter 'target_create_hashi_vault' is set
-      if @api_client.config.client_side_validation && target_create_hashi_vault.nil?
-        fail ArgumentError, "Missing the required parameter 'target_create_hashi_vault' when calling V2Api.target_create_hashi_vault"
+      # 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-hashi-vault'
+      local_var_path = '/target-create-grok'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -30801,7 +31505,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_hashi_vault)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_grok)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetCreateOutput'
@@ -30810,7 +31514,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_create_hashi_vault",
+        :operation => :"V2Api.target_create_grok",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -30821,32 +31525,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_hashi_vault\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @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_k8s [TargetCreateK8s] 
+    # @param target_create_hashi_vault [TargetCreateHashiVault] 
     # @param [Hash] opts the optional parameters
     # @return [TargetCreateOutput]
-    def target_create_k8s(target_create_k8s, opts = {})
-      data, _status_code, _headers = target_create_k8s_with_http_info(target_create_k8s, opts)
+    def target_create_hashi_vault(target_create_hashi_vault, opts = {})
+      data, _status_code, _headers = target_create_hashi_vault_with_http_info(target_create_hashi_vault, opts)
       data
     end
 
-    # @param target_create_k8s [TargetCreateK8s] 
+    # @param target_create_hashi_vault [TargetCreateHashiVault] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
-    def target_create_k8s_with_http_info(target_create_k8s, opts = {})
+    def target_create_hashi_vault_with_http_info(target_create_hashi_vault, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: V2Api.target_create_k8s ...'
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_hashi_vault ...'
       end
-      # verify the required parameter 'target_create_k8s' is set
-      if @api_client.config.client_side_validation && target_create_k8s.nil?
-        fail ArgumentError, "Missing the required parameter 'target_create_k8s' when calling V2Api.target_create_k8s"
+      # verify the required parameter 'target_create_hashi_vault' is set
+      if @api_client.config.client_side_validation && target_create_hashi_vault.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_hashi_vault' when calling V2Api.target_create_hashi_vault"
       end
       # resource path
-      local_var_path = '/target-create-k8s'
+      local_var_path = '/target-create-hashi-vault'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -30865,7 +31569,7 @@ module Akeyless
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_k8s)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_create_hashi_vault)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetCreateOutput'
@@ -30874,7 +31578,7 @@ module Akeyless
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"V2Api.target_create_k8s",
+        :operation => :"V2Api.target_create_hashi_vault",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -30885,12 +31589,140 @@ 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_k8s\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: V2Api#target_create_hashi_vault\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # @param target_create_ldap [TargetCreateLdap] 
+    # @param target_create_k8s [TargetCreateK8s] 
+    # @param [Hash] opts the optional parameters
+    # @return [TargetCreateOutput]
+    def target_create_k8s(target_create_k8s, opts = {})
+      data, _status_code, _headers = target_create_k8s_with_http_info(target_create_k8s, opts)
+      data
+    end
+
+    # @param target_create_k8s [TargetCreateK8s] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(TargetCreateOutput, Integer, Hash)>] TargetCreateOutput data, response status code and response headers
+    def target_create_k8s_with_http_info(target_create_k8s, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: V2Api.target_create_k8s ...'
+      end
+      # verify the required parameter 'target_create_k8s' is set
+      if @api_client.config.client_side_validation && target_create_k8s.nil?
+        fail ArgumentError, "Missing the required parameter 'target_create_k8s' when calling V2Api.target_create_k8s"
+      end
+      # resource path
+      local_var_path = '/target-create-k8s'
+
+      # 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_k8s)
+
+      # 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_k8s",
+        :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_k8s\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      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]
     def target_create_ldap(target_create_ldap, opts = {})
@@ -31082,6 +31914,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]
@@ -31978,6 +32874,70 @@ module Akeyless
       return data, status_code, headers
     end
 
+    # @param target_update_anthropic [TargetUpdateAnthropic] 
+    # @param [Hash] opts the optional parameters
+    # @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_update_anthropic [TargetUpdateAnthropic] 
+    # @param [Hash] opts the optional parameters
+    # @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_update_anthropic ...'
+      end
+      # 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-update-anthropic'
+
+      # 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_anthropic)
+
+      # 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_anthropic",
+        :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_anthropic\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # @param target_update_artifactory [TargetUpdateArtifactory] 
     # @param [Hash] opts the optional parameters
     # @return [TargetUpdateOutput]
@@ -32170,6 +33130,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]
@@ -32234,6 +33258,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]
@@ -33022,7 +34110,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] || {}
@@ -33041,7 +34257,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'
@@ -33050,7 +34266,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,
@@ -33061,32 +34277,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] || {}
@@ -33105,7 +34321,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'
@@ -33114,7 +34330,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,
@@ -33125,32 +34341,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] || {}
@@ -33169,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_k8s)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(target_update_keycloak)
 
       # return_type
       return_type = opts[:debug_return_type] || 'TargetUpdateOutput'
@@ -33178,7 +34394,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,
@@ -33189,7 +34405,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
@@ -33386,6 +34602,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]
@@ -37034,6 +38314,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]