oci 2.14.0 → 2.15.0

data/lib/oci/jms/java_management_service_client_composite_operations.rb

@@ -0,0 +1,273 @@
+# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
+module OCI
+  # This class provides a wrapper around {OCI::Jms::JavaManagementServiceClient} and offers convenience methods
+  # for operations that would otherwise need to be chained together. For example, instead of performing an action
+  # on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource
+  # to enter a given state, you can call a single method in this class to accomplish the same functionality
+  class Jms::JavaManagementServiceClientCompositeOperations
+    # The {OCI::Jms::JavaManagementServiceClient} used to communicate with the service_client
+    #
+    # @return [OCI::Jms::JavaManagementServiceClient]
+    attr_reader :service_client
+
+    # Initializes a new JavaManagementServiceClientCompositeOperations
+    #
+    # @param [OCI::Jms::JavaManagementServiceClient] service_client The client used to communicate with the service.
+    #   Defaults to a new service client created via {OCI::Jms::JavaManagementServiceClient#initialize} with no arguments
+    def initialize(service_client = OCI::Jms::JavaManagementServiceClient.new)
+      @service_client = service_client
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::Jms::JavaManagementServiceClient#change_fleet_compartment} and then waits for the {OCI::Jms::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] fleet_id The [OCID](https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the Fleet.
+    # @param [OCI::Jms::Models::ChangeFleetCompartmentDetails] change_fleet_compartment_details Compartment identifier.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Jms::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Jms::JavaManagementServiceClient#change_fleet_compartment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::Jms::Models::WorkRequest}
+    def change_fleet_compartment_and_wait_for_state(fleet_id, change_fleet_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_fleet_compartment(fleet_id, change_fleet_compartment_details, base_operation_opts)
+      use_util = OCI::Jms::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::Jms::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::Jms::JavaManagementServiceClient#create_fleet} and then waits for the {OCI::Jms::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::Jms::Models::CreateFleetDetails] create_fleet_details Details for the new Fleet.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Jms::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Jms::JavaManagementServiceClient#create_fleet}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::Jms::Models::WorkRequest}
+    def create_fleet_and_wait_for_state(create_fleet_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_fleet(create_fleet_details, base_operation_opts)
+      use_util = OCI::Jms::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::Jms::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::Jms::JavaManagementServiceClient#delete_fleet} and then waits for the {OCI::Jms::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] fleet_id The [OCID](https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the Fleet.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Jms::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Jms::JavaManagementServiceClient#delete_fleet}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::Jms::Models::WorkRequest}
+    def delete_fleet_and_wait_for_state(fleet_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_fleet(fleet_id, base_operation_opts)
+      use_util = OCI::Jms::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::Jms::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::Jms::JavaManagementServiceClient#update_fleet} and then waits for the {OCI::Jms::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] fleet_id The [OCID](https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the Fleet.
+    # @param [OCI::Jms::Models::UpdateFleetDetails] update_fleet_details The new details for the Fleet.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Jms::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Jms::JavaManagementServiceClient#update_fleet}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::Jms::Models::WorkRequest}
+    def update_fleet_and_wait_for_state(fleet_id, update_fleet_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_fleet(fleet_id, update_fleet_details, base_operation_opts)
+      use_util = OCI::Jms::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::Jms::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::Jms::JavaManagementServiceClient#update_fleet_agent_configuration} and then waits for the {OCI::Jms::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] fleet_id The [OCID](https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the Fleet.
+    # @param [OCI::Jms::Models::UpdateFleetAgentConfigurationDetails] update_fleet_agent_configuration_details The new details for the Fleet Agent Configuration.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Jms::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Jms::JavaManagementServiceClient#update_fleet_agent_configuration}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::Jms::Models::WorkRequest}
+    def update_fleet_agent_configuration_and_wait_for_state(fleet_id, update_fleet_agent_configuration_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_fleet_agent_configuration(fleet_id, update_fleet_agent_configuration_details, base_operation_opts)
+      use_util = OCI::Jms::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::Jms::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective, Metrics/LineLength

data/lib/oci/jms/jms.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+module OCI
+  module Jms
+    # Module containing models for requests made to, and responses received from,
+    # OCI Jms services
+    module Models
+    end
+  end
+end
+
+# Require models
+require 'oci/jms/models/action_type'
+require 'oci/jms/models/application_sort_by'
+require 'oci/jms/models/application_usage'
+require 'oci/jms/models/application_usage_collection'
+require 'oci/jms/models/change_fleet_compartment_details'
+require 'oci/jms/models/create_fleet_details'
+require 'oci/jms/models/fleet'
+require 'oci/jms/models/fleet_agent_configuration'
+require 'oci/jms/models/fleet_agent_os_configuration'
+require 'oci/jms/models/fleet_collection'
+require 'oci/jms/models/fleet_summary'
+require 'oci/jms/models/installation_sort_by'
+require 'oci/jms/models/installation_usage'
+require 'oci/jms/models/installation_usage_collection'
+require 'oci/jms/models/jre_sort_by'
+require 'oci/jms/models/jre_usage'
+require 'oci/jms/models/jre_usage_collection'
+require 'oci/jms/models/lifecycle_state'
+require 'oci/jms/models/managed_instance_sort_by'
+require 'oci/jms/models/managed_instance_type'
+require 'oci/jms/models/managed_instance_usage'
+require 'oci/jms/models/managed_instance_usage_collection'
+require 'oci/jms/models/operation_status'
+require 'oci/jms/models/operation_type'
+require 'oci/jms/models/request_summarized_application_usage_details'
+require 'oci/jms/models/request_summarized_installation_usage_details'
+require 'oci/jms/models/request_summarized_jre_usage_details'
+require 'oci/jms/models/request_summarized_managed_instance_usage_details'
+require 'oci/jms/models/sort_by'
+require 'oci/jms/models/sort_order'
+require 'oci/jms/models/summarize_application_usage_fields'
+require 'oci/jms/models/summarize_installation_usage_fields'
+require 'oci/jms/models/summarize_jre_usage_fields'
+require 'oci/jms/models/summarize_managed_instance_usage_fields'
+require 'oci/jms/models/update_fleet_agent_configuration_details'
+require 'oci/jms/models/update_fleet_details'
+require 'oci/jms/models/work_request'
+require 'oci/jms/models/work_request_collection'
+require 'oci/jms/models/work_request_error'
+require 'oci/jms/models/work_request_error_collection'
+require 'oci/jms/models/work_request_log_entry'
+require 'oci/jms/models/work_request_log_entry_collection'
+require 'oci/jms/models/work_request_resource'
+
+# Require generated clients
+require 'oci/jms/java_management_service_client'
+require 'oci/jms/java_management_service_client_composite_operations'
+
+# Require service utilities
+require 'oci/jms/util'

data/lib/oci/jms/models/action_type.rb

@@ -0,0 +1,14 @@
+# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+module OCI
+  module Jms::Models
+    ACTION_TYPE_ENUM = [
+      ACTION_TYPE_CREATED = 'CREATED'.freeze,
+      ACTION_TYPE_DELETED = 'DELETED'.freeze,
+      ACTION_TYPE_IN_PROGRESS = 'IN_PROGRESS'.freeze,
+      ACTION_TYPE_RELATED = 'RELATED'.freeze,
+      ACTION_TYPE_UPDATED = 'UPDATED'.freeze
+    ].freeze
+  end
+end

data/lib/oci/jms/models/application_sort_by.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+module OCI
+  module Jms::Models
+    APPLICATION_SORT_BY_ENUM = [
+      APPLICATION_SORT_BY_TIME_FIRST_SEEN = 'timeFirstSeen'.freeze,
+      APPLICATION_SORT_BY_TIME_LAST_SEEN = 'timeLastSeen'.freeze,
+      APPLICATION_SORT_BY_DISPLAY_NAME = 'displayName'.freeze,
+      APPLICATION_SORT_BY_APPROXIMATE_JRE_COUNT = 'approximateJreCount'.freeze,
+      APPLICATION_SORT_BY_APPROXIMATE_INSTALLATION_COUNT = 'approximateInstallationCount'.freeze,
+      APPLICATION_SORT_BY_APPROXIMATE_MANAGED_INSTANCE_COUNT = 'approximateManagedInstanceCount'.freeze
+    ].freeze
+  end
+end

data/lib/oci/jms/models/application_usage.rb

@@ -0,0 +1,292 @@
+# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+require 'date'
+
+# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
+module OCI
+  # Application usage during a specified time period.
+  # An application is a Java application that can be executed by a Java Runtime installation.
+  # An application is independent of the Java Runtime or its installation.
+  #
+  class Jms::Models::ApplicationUsage
+    # **[Required]** An internal identifier for the application that is unique to a Fleet.
+    #
+    # @return [String]
+    attr_accessor :application_id
+
+    # **[Required]** The name of the application.
+    # @return [String]
+    attr_accessor :display_name
+
+    # **[Required]** The type of the application, denoted by how the application was started.
+    # @return [String]
+    attr_accessor :application_type
+
+    # The approximate count of installations running this application.
+    # @return [Integer]
+    attr_accessor :approximate_installation_count
+
+    # The approximate count of Java Runtimes running this application.
+    # @return [Integer]
+    attr_accessor :approximate_jre_count
+
+    # The approximate count of managed instances reporting this application.
+    # @return [Integer]
+    attr_accessor :approximate_managed_instance_count
+
+    # Lower bound of the specified time period filter.
+    # @return [DateTime]
+    attr_accessor :time_start
+
+    # Upper bound of the specified time period filter.
+    # @return [DateTime]
+    attr_accessor :time_end
+
+    # The date and time the resource was _first_ reported to JMS.
+    # This is potentially _before_ the specified time period provided by the filters.
+    # For example, a resource can be first reported to JMS before the start of a specified time period,
+    # if it is also reported during the time period.
+    #
+    # @return [DateTime]
+    attr_accessor :time_first_seen
+
+    # The date and time the resource was _last_ reported to JMS.
+    # This is potentially _after_ the specified time period provided by the filters.
+    # For example, a resource can be last reported to JMS before the start of a specified time period,
+    # if it is also reported during the time period.
+    #
+    # @return [DateTime]
+    attr_accessor :time_last_seen
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'application_id': :'applicationId',
+        'display_name': :'displayName',
+        'application_type': :'applicationType',
+        'approximate_installation_count': :'approximateInstallationCount',
+        'approximate_jre_count': :'approximateJreCount',
+        'approximate_managed_instance_count': :'approximateManagedInstanceCount',
+        'time_start': :'timeStart',
+        'time_end': :'timeEnd',
+        'time_first_seen': :'timeFirstSeen',
+        'time_last_seen': :'timeLastSeen'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'application_id': :'String',
+        'display_name': :'String',
+        'application_type': :'String',
+        'approximate_installation_count': :'Integer',
+        'approximate_jre_count': :'Integer',
+        'approximate_managed_instance_count': :'Integer',
+        'time_start': :'DateTime',
+        'time_end': :'DateTime',
+        'time_first_seen': :'DateTime',
+        'time_last_seen': :'DateTime'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [String] :application_id The value to assign to the {#application_id} property
+    # @option attributes [String] :display_name The value to assign to the {#display_name} property
+    # @option attributes [String] :application_type The value to assign to the {#application_type} property
+    # @option attributes [Integer] :approximate_installation_count The value to assign to the {#approximate_installation_count} property
+    # @option attributes [Integer] :approximate_jre_count The value to assign to the {#approximate_jre_count} property
+    # @option attributes [Integer] :approximate_managed_instance_count The value to assign to the {#approximate_managed_instance_count} property
+    # @option attributes [DateTime] :time_start The value to assign to the {#time_start} property
+    # @option attributes [DateTime] :time_end The value to assign to the {#time_end} property
+    # @option attributes [DateTime] :time_first_seen The value to assign to the {#time_first_seen} property
+    # @option attributes [DateTime] :time_last_seen The value to assign to the {#time_last_seen} property
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.application_id = attributes[:'applicationId'] if attributes[:'applicationId']
+
+      raise 'You cannot provide both :applicationId and :application_id' if attributes.key?(:'applicationId') && attributes.key?(:'application_id')
+
+      self.application_id = attributes[:'application_id'] if attributes[:'application_id']
+
+      self.display_name = attributes[:'displayName'] if attributes[:'displayName']
+
+      raise 'You cannot provide both :displayName and :display_name' if attributes.key?(:'displayName') && attributes.key?(:'display_name')
+
+      self.display_name = attributes[:'display_name'] if attributes[:'display_name']
+
+      self.application_type = attributes[:'applicationType'] if attributes[:'applicationType']
+
+      raise 'You cannot provide both :applicationType and :application_type' if attributes.key?(:'applicationType') && attributes.key?(:'application_type')
+
+      self.application_type = attributes[:'application_type'] if attributes[:'application_type']
+
+      self.approximate_installation_count = attributes[:'approximateInstallationCount'] if attributes[:'approximateInstallationCount']
+
+      raise 'You cannot provide both :approximateInstallationCount and :approximate_installation_count' if attributes.key?(:'approximateInstallationCount') && attributes.key?(:'approximate_installation_count')
+
+      self.approximate_installation_count = attributes[:'approximate_installation_count'] if attributes[:'approximate_installation_count']
+
+      self.approximate_jre_count = attributes[:'approximateJreCount'] if attributes[:'approximateJreCount']
+
+      raise 'You cannot provide both :approximateJreCount and :approximate_jre_count' if attributes.key?(:'approximateJreCount') && attributes.key?(:'approximate_jre_count')
+
+      self.approximate_jre_count = attributes[:'approximate_jre_count'] if attributes[:'approximate_jre_count']
+
+      self.approximate_managed_instance_count = attributes[:'approximateManagedInstanceCount'] if attributes[:'approximateManagedInstanceCount']
+
+      raise 'You cannot provide both :approximateManagedInstanceCount and :approximate_managed_instance_count' if attributes.key?(:'approximateManagedInstanceCount') && attributes.key?(:'approximate_managed_instance_count')
+
+      self.approximate_managed_instance_count = attributes[:'approximate_managed_instance_count'] if attributes[:'approximate_managed_instance_count']
+
+      self.time_start = attributes[:'timeStart'] if attributes[:'timeStart']
+
+      raise 'You cannot provide both :timeStart and :time_start' if attributes.key?(:'timeStart') && attributes.key?(:'time_start')
+
+      self.time_start = attributes[:'time_start'] if attributes[:'time_start']
+
+      self.time_end = attributes[:'timeEnd'] if attributes[:'timeEnd']
+
+      raise 'You cannot provide both :timeEnd and :time_end' if attributes.key?(:'timeEnd') && attributes.key?(:'time_end')
+
+      self.time_end = attributes[:'time_end'] if attributes[:'time_end']
+
+      self.time_first_seen = attributes[:'timeFirstSeen'] if attributes[:'timeFirstSeen']
+
+      raise 'You cannot provide both :timeFirstSeen and :time_first_seen' if attributes.key?(:'timeFirstSeen') && attributes.key?(:'time_first_seen')
+
+      self.time_first_seen = attributes[:'time_first_seen'] if attributes[:'time_first_seen']
+
+      self.time_last_seen = attributes[:'timeLastSeen'] if attributes[:'timeLastSeen']
+
+      raise 'You cannot provide both :timeLastSeen and :time_last_seen' if attributes.key?(:'timeLastSeen') && attributes.key?(:'time_last_seen')
+
+      self.time_last_seen = attributes[:'time_last_seen'] if attributes[:'time_last_seen']
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        application_id == other.application_id &&
+        display_name == other.display_name &&
+        application_type == other.application_type &&
+        approximate_installation_count == other.approximate_installation_count &&
+        approximate_jre_count == other.approximate_jre_count &&
+        approximate_managed_instance_count == other.approximate_managed_instance_count &&
+        time_start == other.time_start &&
+        time_end == other.time_end &&
+        time_first_seen == other.time_first_seen &&
+        time_last_seen == other.time_last_seen
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+    # @see the `==` method
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [application_id, display_name, application_type, approximate_installation_count, approximate_jre_count, approximate_managed_instance_count, time_start, time_end, time_first_seen, time_last_seen].hash
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_method(attr).call
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective, Metrics/LineLength