oci 2.0.2 → 2.0.3

data/lib/oci/load_balancer/models/load_balancer_policy.rb

@@ -53,10 +53,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -74,7 +74,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/load_balancer_protocol.rb

@@ -53,10 +53,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -74,7 +74,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/load_balancer_shape.rb

@@ -53,10 +53,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -74,7 +74,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/session_persistence_configuration_details.rb

@@ -72,10 +72,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -93,7 +93,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/ssl_configuration.rb

@@ -84,10 +84,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -105,7 +105,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/ssl_configuration_details.rb

@@ -84,10 +84,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -105,7 +105,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/update_backend_details.rb

@@ -105,10 +105,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -126,7 +126,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/update_backend_set_details.rb

@@ -10,9 +10,8 @@ module OCI
     # @return [OCI::LoadBalancer::Models::HealthCheckerDetails]
     attr_accessor :health_checker
 
-    # The load balancer policy for the backend set. The default load balancing policy is 'ROUND_ROBIN'
-    # To get a list of available policies, use the {#list_policies list_policies}
-    # operation.
+    # The load balancer policy for the backend set. To get a list of available policies, use the
+    # {#list_policies list_policies} operation.
     # 
     # Example: `LEAST_CONNECTIONS`
     # 
@@ -90,10 +89,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -111,7 +110,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/update_health_checker_details.rb

@@ -141,10 +141,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -162,7 +162,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/update_listener_details.rb

@@ -87,10 +87,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -108,7 +108,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/update_load_balancer_details.rb

@@ -57,10 +57,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -78,7 +78,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/work_request.rb

@@ -18,6 +18,8 @@ module OCI
     # @return [String]
     attr_accessor :id
 
+    # The current state of the work request.
+    # 
     # @return [String]
     attr_accessor :lifecycle_state
 
@@ -148,10 +150,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -169,7 +171,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/load_balancer/models/work_request_error.rb

@@ -76,10 +76,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -97,7 +97,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/object_storage/models/bucket.rb

@@ -165,10 +165,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -186,7 +186,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/object_storage/models/bucket_summary.rb

@@ -100,10 +100,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -121,7 +121,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/object_storage/models/commit_multipart_upload_details.rb

@@ -64,10 +64,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -85,7 +85,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/object_storage/models/commit_multipart_upload_part_details.rb

@@ -62,10 +62,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -83,7 +83,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/object_storage/models/create_bucket_details.rb

@@ -128,10 +128,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -149,7 +149,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/object_storage/models/create_multipart_upload_details.rb

@@ -93,10 +93,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -114,7 +114,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/object_storage/models/create_preauthenticated_request_details.rb

@@ -97,10 +97,10 @@ 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.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", 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
 
@@ -118,7 +118,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end