ezero-apimatic-sdk 0.0.1

data/lib/env_zero_api/apis/environments_api.rb

@@ -0,0 +1,1082 @@
+# env_zero_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module EnvZeroApi
+  # EnvironmentsApi
+  class EnvironmentsApi < BaseApi
+    # Aborts a deployment that is already running. Returns no content. Aborting
+    # a run mid-apply can leave cloud resources partially applied.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [Object] body Required parameter: The upstream documentation
+    # defines no fields for this request body. Send an empty JSON object `{}`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_abort(id,
+                           body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/environments/deployments/{id}/abort',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(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
+
+    # Cancels a deployment that is queued or waiting for approval, before it
+    # starts applying. Returns the deployment id.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [Object] body Required parameter: The upstream documentation
+    # defines no fields for this request body. Send an empty JSON object `{}`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_cancel(id,
+                            body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/environments/deployments/{id}/cancel',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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(APIHelper.method(:json_serialize))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(EnvironmentApiCancelResponse.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 number of environments in a project as a bare number,
+    # optionally restricted by active state and status. Useful for checking a
+    # project against its environment limit without fetching the environments
+    # themselves.
+    # @param [String] project_id Required parameter: TODO: type description
+    # here
+    # @param [String] is_active Optional parameter: TODO: type description
+    # here
+    # @param [String] status Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_count_by_project(project_id,
+                                      is_active: nil,
+                                      status: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/count',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(project_id, key: 'projectId')
+                                 .is_required(true))
+                   .query_param(new_parameter(is_active, key: 'isActive'))
+                   .query_param(new_parameter(status, key: 'status'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:deserialize_primitive_types))
+                    .deserialize_into(proc do |response| response&.to_f end)
+                    .is_api_response(true)
+                    .is_primitive_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
+
+    # Creates an environment in a project and triggers its first deployment.
+    # `name`, `projectId` and `deployRequest` are required; the remaining fields
+    # set the environment's TTL, tags, variable and configuration-set changes,
+    # continuous deployment and pull-request behaviour, drift detection, and
+    # remote backend settings at creation time. Returns the created environment.
+    # @param [EnvironmentApiCreateRequestBody] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/environments',
+                                     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(EnvironmentApiCreateResponse.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 environments the caller may view, filtered by any combination
+    # of the supported query parameters - organization, project, name, drift
+    # status, tags, active and destroyed state, workspace name, and free-text
+    # search. Results are paginated with `limit` (maximum and default 100) and
+    # `offset`, so a large fleet must be read page by page. Use `excludeFields`
+    # to omit expensive fields such as the latest deployment log.
+    # @param [String] limit Optional parameter: Number of environments per page.
+    # The maximum is 100, with the default value is set to maximum
+    # @param [String] offset Optional parameter: The offset of the first
+    # environment returned. Defaults to 0
+    # @param [String] exclude_fields Optional parameter: Comma-separated list of
+    # fields to exclude from the response (e.g.,
+    # 'latestDeploymentLog.output,latestDeploymentLog.plan')
+    # @param [String] drift_status Optional parameter: Comma-separated list of
+    # drift statuses to filter by (ERROR, DRIFTED, OK, NEVER_RUN, DISABLED)
+    # @param [String] tags Optional parameter: Comma-separated list of tags to
+    # filter by, ANDed together. Each item is either a bare key (matches any
+    # value) or 'key=value' (e.g. 'team=eng,cost-center')
+    # @param [String] is_destroyed Optional parameter: Splits the isActive=false
+    # set. 'true' returns environments env0 destroyed, 'false' returns
+    # environments marked inactive whose resources may still exist. May be sent
+    # only with isActive=false; omit to get both
+    # @param [String] organization_id Optional parameter: TODO: type description
+    # here
+    # @param [String] project_id Optional parameter: TODO: type description
+    # here
+    # @param [String] only_my Optional parameter: TODO: type description here
+    # @param [String] is_active Optional parameter: TODO: type description
+    # here
+    # @param [String] name Optional parameter: TODO: type description here
+    # @param [String] is_remote_backend Optional parameter: TODO: type
+    # description here
+    # @param [String] workspace_name Optional parameter: TODO: type description
+    # here
+    # @param [String] workspace_name_prefix Optional parameter: TODO: type
+    # description here
+    # @param [String] include_sub_environments Optional parameter: TODO: type
+    # description here
+    # @param [String] search_text Optional parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_find_all(limit: nil,
+                              offset: nil,
+                              exclude_fields: nil,
+                              drift_status: nil,
+                              tags: nil,
+                              is_destroyed: nil,
+                              organization_id: nil,
+                              project_id: nil,
+                              only_my: nil,
+                              is_active: nil,
+                              name: nil,
+                              is_remote_backend: nil,
+                              workspace_name: nil,
+                              workspace_name_prefix: nil,
+                              include_sub_environments: nil,
+                              search_text: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(exclude_fields, key: 'excludeFields'))
+                   .query_param(new_parameter(drift_status, key: 'driftStatus'))
+                   .query_param(new_parameter(tags, key: 'tags'))
+                   .query_param(new_parameter(is_destroyed, key: 'isDestroyed'))
+                   .query_param(new_parameter(organization_id, key: 'organizationId'))
+                   .query_param(new_parameter(project_id, key: 'projectId'))
+                   .query_param(new_parameter(only_my, key: 'onlyMy'))
+                   .query_param(new_parameter(is_active, key: 'isActive'))
+                   .query_param(new_parameter(name, key: 'name'))
+                   .query_param(new_parameter(is_remote_backend, key: 'isRemoteBackend'))
+                   .query_param(new_parameter(workspace_name, key: 'workspaceName'))
+                   .query_param(new_parameter(workspace_name_prefix, key: 'workspaceNamePrefix'))
+                   .query_param(new_parameter(include_sub_environments, key: 'includeSubEnvironments'))
+                   .query_param(new_parameter(search_text, key: 'searchText'))
+                   .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(EnvironmentApiEnvironment.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
+
+    # Triggers a deployment of an environment and returns the resulting
+    # deployment log. The request body selects what to deploy and how - the
+    # deployment type, the template revision or repository, variable and
+    # configuration-set changes, targeted resources, a TTL, an approval
+    # requirement, and the automatic drift remediation strategy. Deployment is
+    # asynchronous: poll `GET /environments/deployments/{id}` for the outcome.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [EnvironmentApiDeployRequestBody] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_deploy(id,
+                            body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/environments/{id}/deployments',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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(EnvironmentApiDeployResponse.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 deployment logs of an environment, most useful for
+    # distinguishing deploy, destroy and drift-detection runs and for finding
+    # the drift-detection deployment that a drift cause refers to. Filter by
+    # date range, deployment type, status and deploying user; paginate with
+    # `limit` (maximum and default 100) and `offset`.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [String] limit Optional parameter: Number of deployments per page.
+    # The maximum is 100, with the default value is set to maximum
+    # @param [String] offset Optional parameter: The offset of the first
+    # deployment returned. Defaults to 0
+    # @param [String] from_date Optional parameter: The start date of the first
+    # deployment log in the response. Must be provided with toDate and in the
+    # following format YYYY-MM-DDTHH:mm:ss.sssZ
+    # @param [String] to_date Optional parameter: The start date of the last
+    # deployment log in the response. Must be provided with fromDate and in the
+    # following format YYYY-MM-DDTHH:mm:ss.sssZ
+    # @param [String] deployment_types Optional parameter: The types of the
+    # deployment logs in the response. The types should be in Camel case and
+    # separated by commas. For example:
+    # deploymentTypes=deploy,prPlan,driftDetection
+    # @param [String] statuses Optional parameter: The statuses of the
+    # deployment logs in the response. The statuses should be separated by
+    # commas.
+    # @param [String] deployer_user_ids Optional parameter: The ids of the users
+    # who started the deployments. The ids should be separated by commas.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_find_deployment_logs_by_environment_id(id,
+                                                            limit: nil,
+                                                            offset: nil,
+                                                            from_date: nil,
+                                                            to_date: nil,
+                                                            deployment_types: nil,
+                                                            statuses: nil,
+                                                            deployer_user_ids: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/{id}/deployments',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(from_date, key: 'fromDate'))
+                   .query_param(new_parameter(to_date, key: 'toDate'))
+                   .query_param(new_parameter(deployment_types, key: 'deploymentTypes'))
+                   .query_param(new_parameter(statuses, key: 'statuses'))
+                   .query_param(new_parameter(deployer_user_ids, key: 'deployerUserIds'))
+                   .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(EnvironmentApiDeploymentLog.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
+
+    # Destroys the cloud resources of an environment, returning the id of the
+    # destroy deployment. The query parameters control whether updated code is
+    # checked out, which revision is used, whether state refresh is skipped,
+    # whether the run counts as scheduled, and whether the destroy requires
+    # approval. This is destructive and is refused when destroy protection is
+    # enabled for the environment.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [EnvironmentApiDestroyRequestBody] body Required parameter: TODO:
+    # type description here
+    # @param [CheckoutUpdatedCode] checkout_updated_code Optional parameter:
+    # Checkout updated code
+    # @param [IsScheduledRun] is_scheduled_run Optional parameter: Is scheduled
+    # run
+    # @param [SkipStateRefresh] skip_state_refresh Optional parameter: Skip
+    # automatic state refresh
+    # @param [String] revision Optional parameter: Revision
+    # @param [RequiresApproval] requires_approval Optional parameter: Requires
+    # approval
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_destroy(id,
+                             body,
+                             checkout_updated_code: nil,
+                             is_scheduled_run: nil,
+                             skip_state_refresh: nil,
+                             revision: nil,
+                             requires_approval: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/environments/{id}/destroy',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .query_param(new_parameter(checkout_updated_code, key: 'checkoutUpdatedCode'))
+                   .query_param(new_parameter(is_scheduled_run, key: 'isScheduledRun'))
+                   .query_param(new_parameter(skip_state_refresh, key: 'skipStateRefresh'))
+                   .query_param(new_parameter(revision, key: 'revision'))
+                   .query_param(new_parameter(requires_approval, key: 'requiresApproval'))
+                   .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(EnvironmentApiDestroyResponse.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
+
+    # Downloads the complete Terraform/OpenTofu plan JSON (the output of 'show
+    # -json') of the given deployment,
+    # including resources with no changes - unlike the parsed plan returned by
+    # 'GET /environments/deployments/{id}?fields=plan',
+    # which contains only changed resources. Intended for external policy
+    # evaluation (for example Checkov).
+    # Responses:
+    #   * 302 (default) - the 'Location' header holds a short-lived (5 minutes)
+    # signed download URL. Follow the
+    #     redirect to download the file, for example with 'curl -L'.
+    #   * 200 - only when 'redirect=false' is passed: the same signed URL is
+    # returned as a JSON body ({ "url": "..." })
+    #     instead of a redirect. Browser clients should prefer this, since
+    # following the 302 with a cross-origin
+    #     request that carries custom headers triggers a CORS preflight against
+    # the storage bucket.
+    #   * 404 - the deployment does not exist, or no plan JSON is available for
+    # it (see below).
+    #   * 403 - the caller is not allowed to view the deployment's environment.
+    # NOTE: the generated schema below documents only the 200 response body; the
+    # default response of this endpoint
+    # is the 302 described above.
+    # Sensitive values are masked: anything Terraform marks as sensitive is
+    # replaced with '<sensitive>', and values
+    # of sensitive env zero variables are redacted. Expect masked placeholders
+    # rather than real secrets in the file.
+    # A plan JSON is available only when all of the following hold, otherwise
+    # the endpoint returns 404:
+    #   * the deployment is a deploy, destroy, or dry run - drift detection, PR
+    # plan and remote plan deployments do not produce one
+    #   * the template is Terraform, OpenTofu or Terragrunt (Terragrunt run-all
+    # is not supported)
+    #   * the deployment reached and completed its plan step
+    #   * the deployment ran on an agent version that supports the feature
+    # (self-hosted agents may need an upgrade)
+    #   * the deployment is less than 30 days old - plan JSON files are retained
+    # for 30 days and then deleted
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [String] redirect Optional parameter: Pass 'false' to receive the
+    # signed download URL as a JSON body ({ "url": "..." }) instead of a 302
+    # redirect. Any other value, or omitting the parameter, returns the
+    # redirect.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_get_deployment_plan_json(id,
+                                              redirect: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/deployments/{id}/plan-json',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(redirect, key: 'redirect'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(proc do |response, should_symbolize|
+                      APIHelper.deserialize_union_type(
+                        UnionTypeLookUp.get(:EnvironmentApiGetDeploymentPlanJsonResponse2),
+                        response, should_symbolize, true
+                      )
+                    end)
+                    .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 drift status recorded for a drift-detection deployment,
+    # including the deployment log itself, the date of the cloud change events
+    # currently held for it, and the status of the event scan that produced
+    # them.
+    # @param [String] id Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_find_deployment_drift_status(id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/deployments/{id}/drift-status',
+                                     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(EnvironmentApiFindDeploymentDriftStatusResponse.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 full detail of one cloud change event on a drifted resource,
+    # for inspecting exactly what changed outside of env zero.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [String] resource_id Required parameter: TODO: type description
+    # here
+    # @param [String] event_id Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_get_drifted_resource_event_details(id,
+                                                        resource_id,
+                                                        event_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/deployments/{id}/resources/{resourceId}/events/{eventId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(resource_id, key: 'resourceId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(event_id, key: 'eventId')
+                                    .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(EnvironmentApiGetDriftedResourceEventDetailsResponse.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 cloud change events recorded against a single drifted resource
+    # of a drift-detection deployment, together with the time window the events
+    # cover.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [String] resource_id Required parameter: TODO: type description
+    # here
+    # @param [String] resource_type Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_get_drifted_resource_events(id,
+                                                 resource_id,
+                                                 resource_type)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/deployments/{id}/resources/{resourceId}/{resourceType}/events',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(resource_id, key: 'resourceId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(resource_type, key: 'resourceType')
+                                    .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(EnvironmentApiGetDriftedResourceEventsResponse.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 a deployment log by id, including its type, status, timings,
+    # output, and any error and failed command. Use `fields` or `exclude_fields`
+    # to narrow the response - for example requesting only the plan. Poll this
+    # to follow an asynchronous deployment to completion.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [String] exclude_fields Optional parameter: Fields to filter from
+    # the response body
+    # @param [String] fields Optional parameter: Fields to get from the response
+    # body
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_find_deployment_log_by_id(id,
+                                               exclude_fields: nil,
+                                               fields: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/deployments/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(exclude_fields, key: 'exclude_fields'))
+                   .query_param(new_parameter(fields, key: 'fields'))
+                   .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(EnvironmentApiFindDeploymentLogByIdResponse.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
+
+    # Resumes a deployment that is waiting for user approval, letting the apply
+    # proceed. Returns the deployment id.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [Object] body Required parameter: The upstream documentation
+    # defines no fields for this request body. Send an empty JSON object `{}`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_resume(id,
+                            body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/environments/deployments/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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(APIHelper.method(:json_serialize))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(EnvironmentApiResumeResponse.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 a single environment by id, including its status, drift status,
+    # lock state, tags, TTL, and latest deployment log. Use `fields` or
+    # `exclude_fields` to narrow the response.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [String] exclude_fields Optional parameter: TODO: type description
+    # here
+    # @param [String] fields Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_find_by_id(id,
+                                exclude_fields: nil,
+                                fields: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(exclude_fields, key: 'exclude_fields'))
+                   .query_param(new_parameter(fields, key: 'fields'))
+                   .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(EnvironmentApiFindByIdResponse.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
+
+    # Updates an environment's settings - its name, approval requirement,
+    # archived state, continuous deployment and pull-request plan behaviour, and
+    # remote backend and remote apply flags. Fields left out are unchanged.
+    # Returns the updated environment.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [EnvironmentApiUpdateRequestBody] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_update(id,
+                            body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/environments/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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(EnvironmentApiUpdateResponse.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 deployment outputs of the environments in a project, keyed by
+    # environment, so that one environment's outputs can be consumed as
+    # another's inputs.
+    # @param [String] project_id Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_get_environments_outputs(project_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environment-outputs',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(project_id, key: 'projectId')
+                                 .is_required(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(EnvironmentApiGetEnvironmentsOutputsResponse.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, per deployment id, how many resources its stored plan would
+    # create, update, delete,
+    # recreate or only change in state, plus the destructive changes it would
+    # make. Reads the plan already
+    # stored for the deployment; it runs no new plan.
+    # A recreate is destructive and is also counted under 'recreate'. 'metadata'
+    # counts resources whose
+    # state changes but whose infrastructure does not (a move or an import), and
+    # never appears in
+    # 'destructive'.
+    # 'destructive' is capped at 50 entries; 'destructiveTotal' is the true
+    # count and
+    # 'destructiveTypeCounts' covers every destructive change, not just the
+    # returned ones.
+    # 'planReadable' is false when no readable plan is stored, in which case
+    # every count is absent rather
+    # than zero. A legacy deployment that stored only a plan summary is readable
+    # but partial: it carries
+    # 'create', 'update', 'delete' and 'destructiveTotal' and omits 'recreate',
+    # 'metadata', 'destructive'
+    # and 'destructiveTypeCounts', so read each field for presence rather than
+    # inferring it from
+    # 'planReadable'. Deployments the caller may not view are absent from the
+    # response.
+    # At most 200 ids per request.
+    # @param [String] deployment_log_ids Required parameter: Comma-separated
+    # deployment ids. At most 200.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_get_plan_impact(deployment_log_ids)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/deployments/plan-impact',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(deployment_log_ids, key: 'deploymentLogIds')
+                                 .is_required(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(EnvironmentApiGetPlanImpactPlanImpact.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
+
+    # Returns the resources recorded for a deployment, as parsed from its plan
+    # or state.
+    # @param [String] id Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_find_resources(id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/deployments/{id}/resources',
+                                     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(EnvironmentApiEnvironmentResource.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
+
+    # Returns every tag key on the organization's environments that the caller
+    # may view, mapped to its distinct values
+    # @param [String] organization_id Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_find_tags_by_organization_id(organization_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/environments/tags',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(organization_id, key: 'organizationId')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:dynamic_deserializer))
+                    .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 or unlocks an environment. `isLocked` is required and `reason`
+    # records why, shown to project members. While locked, deploy, destroy, plan
+    # and drift detection will not run for the environment. Returns the
+    # resulting lock status.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [EnvironmentApiUpdateEnvironmentLockRequestBody] body Required
+    # parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_update_environment_lock(id,
+                                             body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/environments/{id}/lock',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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(EnvironmentApiUpdateEnvironmentLockResponse.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
+
+    # Remediate a drifted environment, using a drift detection deployment ID
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [Object] body Required parameter: The upstream documentation
+    # defines no fields for this request body. Send an empty JSON object `{}`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_remediate_drift(id,
+                                     body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/environments/deployments/{id}/remediate-drift',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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(APIHelper.method(:json_serialize))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(EnvironmentApiRemediateDriftResponse.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
+
+    # Starts a scan for the cloud change events behind a drift-detection
+    # deployment, which is what makes per-resource drift events available for
+    # that deployment. The scan runs asynchronously and the call returns no
+    # content; poll `GET /environments/deployments/{id}/drift-status` for the
+    # scan status.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [Object] body Required parameter: The upstream documentation
+    # defines no fields for this request body. Send an empty JSON object `{}`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_drift_scan(id,
+                                body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/environments/deployments/{id}/drift-scan',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(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
+
+    # Applies a JSON merge-patch (RFC 7396) to the environment's tags - a
+    # non-empty array replaces that key's values wholesale, null removes the
+    # key, and keys that are not mentioned are left untouched
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [Hash[String, Array[String]]] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_update_tags(id,
+                                 body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/environments/{id}/tags',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true)
+                                .validator(proc do |value|
+                                  UnionTypeLookUp.get(:EnvironmentApiUpdateTagsRequestBody)
+                                                 .validate(value)
+                                end))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(APIHelper.method(:json_serialize))
+                   .auth(Single.new('env0_API_Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(EnvironmentApiUpdateTagsResponse.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
+
+    # Sets an environment's time-to-live, after which env zero destroys it
+    # automatically. `type` is required and selects whether the environment has
+    # a finite or infinite lifespan, with `value` giving the deadline. Maximum
+    # TTL is constrained by the organization's and project's TTL policy and is
+    # measured from the environment's creation time. Returns the updated
+    # environment.
+    # @param [String] id Required parameter: TODO: type description here
+    # @param [EnvironmentApiTtlRequestBody] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def environments_ttl(id,
+                         body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/environments/{id}/ttl',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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(EnvironmentApiTtlResponse.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