oci 2.1.0 → 2.1.1

data/lib/oci/dns/dns_client_composite_operations.rb

@@ -0,0 +1,143 @@
+# Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+
+# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
+module OCI
+  # This class provides a wrapper around {OCI::Dns::DnsClient} 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 Dns::DnsClientCompositeOperations
+    # The {OCI::Dns::DnsClient} used to communicate with the service_client
+    #
+    # @return [OCI::Dns::DnsClient]
+    attr_reader :service_client
+
+    # Initializes a new DnsClientCompositeOperations
+    #
+    # @param [OCI::Dns::DnsClient] service_client The client used to communicate with the service.
+    #   Defaults to a new service client created via {OCI::Dns::DnsClient#initialize} with no arguments
+    def initialize(service_client = OCI::Dns::DnsClient.new)
+      @service_client = service_client
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::Dns::DnsClient#create_zone} and then waits for the {OCI::Dns::Models::Zone} acted upon
+    # to enter the given state(s).
+    #
+    # @param [OCI::Dns::Models::CreateZoneDetails] create_zone_details Details for creating a new zone.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Dns::Models::Zone#lifecycle_state}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Dns::DnsClient#create_zone}
+    # @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 with data of type {OCI::Dns::Models::Zone}
+    def create_zone_and_wait_for_state(create_zone_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_zone(create_zone_details, base_operation_opts)
+
+      return operation_result if wait_for_states.empty?
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.data.id
+
+      begin
+        waiter_result = @service_client.get_zone(wait_for_resource_id).wait_until(
+          eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.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
+        )
+        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::Dns::DnsClient#delete_zone} and then waits for the {OCI::Dns::Models::Zone} acted upon
+    # to enter the given state(s).
+    #
+    # @param [String] zone_name_or_id The name or OCID of the target zone.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Dns::Models::Zone#lifecycle_state}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Dns::DnsClient#delete_zone}
+    # @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 with data of type nil
+    def delete_zone_and_wait_for_state(zone_name_or_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      initial_get_result = @service_client.get_zone(zone_name_or_id)
+      operation_result = @service_client.delete_zone(zone_name_or_id, base_operation_opts)
+
+      return operation_result if wait_for_states.empty?
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+
+      begin
+        waiter_result = initial_get_result.wait_until(
+          eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.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,
+          succeed_on_not_found: true
+        )
+        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::Dns::DnsClient#update_zone} and then waits for the {OCI::Dns::Models::Zone} acted upon
+    # to enter the given state(s).
+    #
+    # @param [String] zone_name_or_id The name or OCID of the target zone.
+    # @param [OCI::Dns::Models::UpdateZoneDetails] update_zone_details New data for the zone.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::Dns::Models::Zone#lifecycle_state}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::Dns::DnsClient#update_zone}
+    # @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 with data of type {OCI::Dns::Models::Zone}
+    def update_zone_and_wait_for_state(zone_name_or_id, update_zone_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_zone(zone_name_or_id, update_zone_details, base_operation_opts)
+
+      return operation_result if wait_for_states.empty?
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.data.id
+
+      begin
+        waiter_result = @service_client.get_zone(wait_for_resource_id).wait_until(
+          eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.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
+        )
+        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/dns/models/create_zone_details.rb

@@ -2,22 +2,24 @@
 
 require 'date'
 
+# rubocop:disable Lint/UnneededCopDisableDirective
 module OCI
   # The body for defining a new zone.
   #
-  class Dns::Models::CreateZoneDetails
-
-    ZONE_TYPE_ENUM = [ZONE_TYPE_PRIMARY = 'PRIMARY',
-                ZONE_TYPE_SECONDARY = 'SECONDARY']
+  class Dns::Models::CreateZoneDetails # rubocop:disable Metrics/LineLength
+    ZONE_TYPE_ENUM = [
+      ZONE_TYPE_PRIMARY = 'PRIMARY'.freeze,
+      ZONE_TYPE_SECONDARY = 'SECONDARY'.freeze
+    ].freeze
 
     # **[Required]** The name of the zone.
     # @return [String]
     attr_accessor :name
 
     # **[Required]** The type of the zone. Must be either `PRIMARY` or `SECONDARY`.
-    # 
+    #
     # @return [String]
-    attr_accessor :zone_type
+    attr_reader :zone_type
 
     # **[Required]** The OCID of the compartment containing the zone.
     # @return [String]
@@ -27,6 +29,33 @@ module OCI
     # @return [Array<OCI::Dns::Models::ExternalMaster>]
     attr_accessor :external_masters
 
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'name': :'name',
+        'zone_type': :'zoneType',
+        'compartment_id': :'compartmentId',
+        'external_masters': :'externalMasters'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'name': :'String',
+        'zone_type': :'String',
+        'compartment_id': :'String',
+        'external_masters': :'Array<OCI::Dns::Models::ExternalMaster>'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
 
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
@@ -38,76 +67,73 @@ module OCI
       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}
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
 
-      if attributes[:'name']
-        self.name = attributes[:'name']
-      end
+      self.name = attributes[:'name'] if attributes[:'name']
 
-      if attributes[:'zoneType']
-        self.zone_type = attributes[:'zoneType']
-      end
+      self.zone_type = attributes[:'zoneType'] if attributes[:'zoneType']
 
       raise 'You cannot provide both :zoneType and :zone_type' if attributes.key?(:'zoneType') && attributes.key?(:'zone_type')
 
-      if attributes[:'zone_type']
-        self.zone_type = attributes[:'zone_type']
-      end
+      self.zone_type = attributes[:'zone_type'] if attributes[:'zone_type']
 
-      if attributes[:'compartmentId']
-        self.compartment_id = attributes[:'compartmentId']
-      end
+      self.compartment_id = attributes[:'compartmentId'] if attributes[:'compartmentId']
 
       raise 'You cannot provide both :compartmentId and :compartment_id' if attributes.key?(:'compartmentId') && attributes.key?(:'compartment_id')
 
-      if attributes[:'compartment_id']
-        self.compartment_id = attributes[:'compartment_id']
-      end
+      self.compartment_id = attributes[:'compartment_id'] if attributes[:'compartment_id']
 
-      if attributes[:'externalMasters']
-        self.external_masters = attributes[:'externalMasters']
-      end
+      self.external_masters = attributes[:'externalMasters'] if attributes[:'externalMasters']
 
       raise 'You cannot provide both :externalMasters and :external_masters' if attributes.key?(:'externalMasters') && attributes.key?(:'external_masters')
 
-      if attributes[:'external_masters']
-        self.external_masters = attributes[:'external_masters']
-      end
-
+      self.external_masters = attributes[:'external_masters'] if attributes[:'external_masters']
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
 
     # Custom attribute writer method checking allowed values (enum).
     # @param [Object] zone_type Object to be assigned
     def zone_type=(zone_type)
-      if zone_type && !ZONE_TYPE_ENUM.include?(zone_type)
-        raise "Invalid value for 'zone_type': this must be one of the values in ZONE_TYPE_ENUM."
-      else
-        @zone_type = zone_type
-      end
+      # rubocop: disable Metrics/LineLength
+      raise "Invalid value for 'zone_type': this must be one of the values in ZONE_TYPE_ENUM." if zone_type && !ZONE_TYPE_ENUM.include?(zone_type)
+      # rubocop: enable Metrics/LineLength
+      @zone_type = zone_type
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+
     # Checks equality by comparing each attribute.
-    # @param [Object] other_object to be compared
-    def ==(other_object)
-      return true if self.equal?(other_object)
-      self.class == other_object.class &&
-          name == other_object.name &&
-          zone_type == other_object.zone_type &&
-          compartment_id == other_object.compartment_id &&
-          external_masters == other_object.external_masters
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+      self.class == other.class &&
+        name == other.name &&
+        zone_type == other.zone_type &&
+        compartment_id == other.compartment_id &&
+        external_masters == other.external_masters
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
 
     # @see the `==` method
-    # @param [Object] other_object to be compared
-    def eql?(other_object)
-      self == other_object
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
       [name, zone_type, compartment_id, external_masters].hash
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
 
     # Builds the object from hash
     # @param [Hash] attributes Model attributes in the form of hash
@@ -119,15 +145,22 @@ module OCI
           # 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)
-            self.public_method("#{key}=").call(attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            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?
-          self.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
+          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
@@ -151,11 +184,11 @@ module OCI
 
     # 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 
+    # @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) }
+        value.compact.map { |v| _to_hash(v) }
       elsif value.is_a?(Hash)
         {}.tap do |hash|
           value.each { |k, v| hash[k] = _to_hash(v) }
@@ -166,27 +199,6 @@ module OCI
         value
       end
     end
-
-
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      { 
-        :'name' => :'name',
-        :'zone_type' => :'zoneType',
-        :'compartment_id' => :'compartmentId',
-        :'external_masters' => :'externalMasters'
-      }
-    end
-
-    # Attribute type mapping.
-    def self.swagger_types
-      { 
-        :'name' => :'String',
-        :'zone_type' => :'String',
-        :'compartment_id' => :'String',
-        :'external_masters' => :'Array<OCI::Dns::Models::ExternalMaster>'
-      }
-    end
   end
 end
+# rubocop:enable Lint/UnneededCopDisableDirective

data/lib/oci/dns/models/external_master.rb

@@ -2,9 +2,10 @@
 
 require 'date'
 
+# rubocop:disable Lint/UnneededCopDisableDirective
 module OCI
   # An external master name server used as the source of zone data.
-  class Dns::Models::ExternalMaster
+  class Dns::Models::ExternalMaster # rubocop:disable Metrics/LineLength
     # **[Required]** The server's IP address (IPv4 or IPv6).
     # @return [String]
     attr_accessor :address
@@ -16,6 +17,31 @@ module OCI
     # @return [OCI::Dns::Models::TSIG]
     attr_accessor :tsig
 
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'address': :'address',
+        'port': :'port',
+        'tsig': :'tsig'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'address': :'String',
+        'port': :'Integer',
+        'tsig': :'OCI::Dns::Models::TSIG'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
 
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
@@ -26,43 +52,49 @@ module OCI
       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}
-
-      if attributes[:'address']
-        self.address = attributes[:'address']
-      end
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
 
-      if attributes[:'port']
-        self.port = attributes[:'port']
-      end
+      self.address = attributes[:'address'] if attributes[:'address']
 
-      if attributes[:'tsig']
-        self.tsig = attributes[:'tsig']
-      end
+      self.port = attributes[:'port'] if attributes[:'port']
 
+      self.tsig = attributes[:'tsig'] if attributes[:'tsig']
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/LineLength, 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_object to be compared
-    def ==(other_object)
-      return true if self.equal?(other_object)
-      self.class == other_object.class &&
-          address == other_object.address &&
-          port == other_object.port &&
-          tsig == other_object.tsig
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+      self.class == other.class &&
+        address == other.address &&
+        port == other.port &&
+        tsig == other.tsig
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
 
     # @see the `==` method
-    # @param [Object] other_object to be compared
-    def eql?(other_object)
-      self == other_object
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
       [address, port, tsig].hash
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
 
     # Builds the object from hash
     # @param [Hash] attributes Model attributes in the form of hash
@@ -74,15 +106,22 @@ module OCI
           # 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)
-            self.public_method("#{key}=").call(attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            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?
-          self.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
+          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
@@ -106,11 +145,11 @@ module OCI
 
     # 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 
+    # @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) }
+        value.compact.map { |v| _to_hash(v) }
       elsif value.is_a?(Hash)
         {}.tap do |hash|
           value.each { |k, v| hash[k] = _to_hash(v) }
@@ -121,25 +160,6 @@ module OCI
         value
       end
     end
-
-
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      { 
-        :'address' => :'address',
-        :'port' => :'port',
-        :'tsig' => :'tsig'
-      }
-    end
-
-    # Attribute type mapping.
-    def self.swagger_types
-      { 
-        :'address' => :'String',
-        :'port' => :'Integer',
-        :'tsig' => :'OCI::Dns::Models::TSIG'
-      }
-    end
   end
 end
+# rubocop:enable Lint/UnneededCopDisableDirective