ezero-apimatic-sdk 0.0.1

data/lib/env_zero_api/apis/bulk_operations_api.rb

@@ -0,0 +1,297 @@
+# env_zero_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module EnvZeroApi
+  # BulkOperationsApi
+  class BulkOperationsApi < BaseApi
+    # Applies the same tags to every selected environment - a key that already
+    # exists has its values replaced wholesale, and keys that are not listed are
+    # left untouched
+    # @param [BulkOperationsApiBulkAddTagsRequestBody] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_add_tags(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/add-tags',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkAddTagsResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Marks each of the given environments as inactive. Returns an
+    # `operationId`; poll `GET /bulk-operations/{operationId}` for the
+    # per-environment outcome.
+    # @param [BulkOperationsApiBulkArchiveRequestBody] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_archive(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/archive',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkArchiveResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Triggers a deployment on each of the given environments, using the shared
+    # deployment options in `data`. Returns an `operationId`; poll `GET
+    # /bulk-operations/{operationId}` for the per-environment outcome.
+    # Environments the caller cannot deploy are reported there rather than
+    # failing the request.
+    # @param [BulkOperationsApiBulkDeployRequestBody] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_deploy(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/deploy',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkDeployResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Destroys each of the given environments, using the shared options in
+    # `data`. Returns an `operationId`; poll `GET
+    # /bulk-operations/{operationId}` for the per-environment outcome. This is
+    # destructive and affects every listed environment.
+    # @param [BulkOperationsApiBulkDestroyRequestBody] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_destroy(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/destroy',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkDestroyResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Locks each of the given environments, using the shared lock options in
+    # `data`, preventing deploy, destroy, plan and drift detection from running
+    # on them. Returns an `operationId`; poll `GET
+    # /bulk-operations/{operationId}` for the per-environment outcome.
+    # @param [BulkOperationsApiBulkLockRequestBody] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_lock(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/lock',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkLockResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Removes the listed tag keys, values and all, from every selected
+    # environment - a key an environment does not carry is a no-op
+    # @param [BulkOperationsApiBulkRemoveTagsRequestBody] body Required
+    # parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_remove_tags(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/remove-tags',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkRemoveTagsResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Runs a task on each of the given environments, using the shared task
+    # options in `data`. Returns an `operationId`; poll `GET
+    # /bulk-operations/{operationId}` for the per-environment outcome.
+    # @param [BulkOperationsApiBulkRunTaskRequestBody] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_run_task(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/run-task',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkRunTaskResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Unlocks each of the given environments. Returns an `operationId`; poll
+    # `GET /bulk-operations/{operationId}` for the per-environment outcome.
+    # @param [BulkOperationsApiBulkUnlockRequestBody] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_bulk_unlock(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/bulk-operations/unlock',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiBulkUnlockResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Returns the per-environment status of a bulk operation - only the user who
+    # triggered it may read it
+    # @param [String] operation_id Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def bulk_operations_get_bulk_operation(operation_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/bulk-operations/{operationId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(operation_id, key: 'operationId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BulkOperationsApiGetBulkOperationResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+  end
+end

data/lib/env_zero_api/apis/configuration_api.rb

@@ -0,0 +1,311 @@
+# env_zero_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module EnvZeroApi
+  # ConfigurationApi
+  class ConfigurationApi < BaseApi
+    # Assigns the configuration sets named in `setIds` to the given scope, so
+    # their variables apply to deployments there. Returns no content.
+    # @param [String] scope Required parameter: TODO: type description here
+    # @param [String] scope_id Required parameter: TODO: type description here
+    # @param [String] set_ids Required parameter: TODO: type description here
+    # @param [Object] body Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_assign_configuration_sets_to_scope(scope,
+                                                         scope_id,
+                                                         set_ids,
+                                                         body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/configuration-sets/assignments/{scope}/{scopeId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(scope, key: 'scope')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(scope_id, key: 'scopeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(set_ids, key: 'setIds')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .body_serializer(APIHelper.method(:json_serialize))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .is_nullable_response(true)
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Returns the configuration sets assigned to the given scope.
+    # @param [String] scope Required parameter: TODO: type description here
+    # @param [String] scope_id Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_find_set_assignments_by_scope(scope,
+                                                    scope_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/configuration-sets/assignments/{scope}/{scopeId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(scope, key: 'scope')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(scope_id, key: 'scopeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConfigurationSet.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Creates a configuration set - a reusable, named group of variables that
+    # can be assigned to templates, projects or environments. `name`, `scope`
+    # and `scopeId` are required. Returns the created set.
+    # @param [ConfigurationApiCreateConfigurationSetRequestBody] body Required
+    # parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_create_configuration_set(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/configuration-sets',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConfigurationApiCreateConfigurationSetResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Returns the configuration sets created at the given scope. Set
+    # `includeHigherScopes` to also return sets created at scopes above it.
+    # @param [String] scope Required parameter: TODO: type description here
+    # @param [String] scope_id Required parameter: TODO: type description here
+    # @param [String] include_higher_scopes Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_find_sets_by_creation_scope(scope,
+                                                  scope_id,
+                                                  include_higher_scopes: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/configuration-sets',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(scope, key: 'scope')
+                                 .is_required(true))
+                   .query_param(new_parameter(scope_id, key: 'scopeId')
+                                 .is_required(true))
+                   .query_param(new_parameter(include_higher_scopes, key: 'includeHigherScopes'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConfigurationSet.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Creates or updates configuration variables. Variables are resolved through
+    # env zero's scope hierarchy, so a variable set at a lower scope overrides
+    # the same variable set higher up. Returns the resulting variables.
+    # @param [Array[ConfigurationPropertyRequest]] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_create_or_update_variable(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/configuration',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConfigurationPropertyResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Lists all variables for the provided scope(s).
+    # If more than one scope is given - variables will be overridden by lower
+    # level scopes - just like env zero does.
+    # For example - Provided both organizationId and projectId,
+    # if a variable exists on both scopes, a single instance of it will be
+    # returned, with its Project scope value
+    # @param [String] organization_id Required parameter: Used for querying
+    # variables defined on organization level
+    # @param [String] project_id Optional parameter: Used for querying variables
+    # defined on project level
+    # @param [String] blueprint_id Optional parameter: Used for querying
+    # variables defined on blueprint level
+    # @param [String] environment_id Optional parameter: Used for querying
+    # variables defined on environment level
+    # @param [String] deployment_log_id Optional parameter: Used for querying
+    # variables defined for a specific deployment
+    # @param [String] workflow_environment_id Optional parameter: Used for
+    # querying variables defined on workflow environment level
+    # @param [String] workflow_blueprint_id Optional parameter: Used for
+    # querying variables defined on workflow blueprint level
+    # @param [String] workflow_blueprint_id_sub_alias Optional parameter: Used
+    # for querying sub environment blueprint variables, constructed as
+    # {workflowBlueprintId}:{subAlias}
+    # @param [String] set_id Optional parameter: Used for querying variables
+    # defined in a configuration set
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_find_variables_by_scope(organization_id,
+                                              project_id: nil,
+                                              blueprint_id: nil,
+                                              environment_id: nil,
+                                              deployment_log_id: nil,
+                                              workflow_environment_id: nil,
+                                              workflow_blueprint_id: nil,
+                                              workflow_blueprint_id_sub_alias: nil,
+                                              set_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/configuration',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(organization_id, key: 'organizationId')
+                                 .is_required(true))
+                   .query_param(new_parameter(project_id, key: 'projectId'))
+                   .query_param(new_parameter(blueprint_id, key: 'blueprintId'))
+                   .query_param(new_parameter(environment_id, key: 'environmentId'))
+                   .query_param(new_parameter(deployment_log_id, key: 'deploymentLogId'))
+                   .query_param(new_parameter(workflow_environment_id, key: 'workflowEnvironmentId'))
+                   .query_param(new_parameter(workflow_blueprint_id, key: 'workflowBlueprintId'))
+                   .query_param(new_parameter(workflow_blueprint_id_sub_alias, key: 'workflowBlueprintIdSubAlias'))
+                   .query_param(new_parameter(set_id, key: 'setId'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConfigurationApiFindVariablesByScopeOverridingConfigurationProperty.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Deletes a configuration variable by id.
+    # @param [String] id Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_delete_variable(id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/configuration/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+
+    # Returns a single configuration variable by id, including its scope, type,
+    # value, and whether it is sensitive, read-only or required. The value of a
+    # sensitive variable is not returned.
+    # @param [String] id Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def configuration_find_variable_by_id(id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/configuration/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConfigurationApiFindVariableByIdResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Authentication failed - the API key ID or secret is missing or'\
+                                  ' invalid.',
+                                 ErrorException)
+                    .local_error('403',
+                                 'The authenticated key lacks permission for this resource, or'\
+                                  ' the route does not exist for the caller.',
+                                 ErrorException))
+        .execute
+    end
+  end
+end