oci 2.0.6 → 2.0.7

data/lib/oci/core/models/volume_backup_policy_assignment.rb

@@ -0,0 +1,159 @@
+# Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  # Specifies that a particular volume backup policy is assigned to an asset such as a volume.
+  class Core::Models::VolumeBackupPolicyAssignment
+    # **[Required]** The OCID of the asset (e.g. a volume) to which the policy has been assigned.
+    # @return [String]
+    attr_accessor :asset_id
+
+    # **[Required]** The OCID of the volume backup policy assignment.
+    # @return [String]
+    attr_accessor :id
+
+    # **[Required]** The OCID of the volume backup policy that has been assigned to an asset.
+    # @return [String]
+    attr_accessor :policy_id
+
+    # **[Required]** The date and time the volume backup policy assignment was created. Format defined by RFC3339.
+    # 
+    # @return [DateTime]
+    attr_accessor :time_created
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [String] :assetId The value to assign to the {#asset_id} property
+    # @option attributes [String] :id The value to assign to the {#id} property
+    # @option attributes [String] :policyId The value to assign to the {#policy_id} property
+    # @option attributes [DateTime] :timeCreated The value to assign to the {#time_created} 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}
+
+      if attributes[:'assetId']
+        self.asset_id = attributes[:'assetId']
+      end
+
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      end
+
+      if attributes[:'policyId']
+        self.policy_id = attributes[:'policyId']
+      end
+
+      if attributes[:'timeCreated']
+        self.time_created = attributes[:'timeCreated']
+      end
+
+    end
+
+    # 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 &&
+          asset_id == other_object.asset_id &&
+          id == other_object.id &&
+          policy_id == other_object.policy_id &&
+          time_created == other_object.time_created
+    end
+
+    # @see the `==` method
+    # @param [Object] other_object to be compared
+    def eql?(other_object)
+      self == other_object
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [asset_id, id, policy_id, time_created].hash
+    end
+
+    # 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)
+            self.public_method("#{key}=").call(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.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
+
+    # 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
+
+
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      { 
+        :'asset_id' => :'assetId',
+        :'id' => :'id',
+        :'policy_id' => :'policyId',
+        :'time_created' => :'timeCreated'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'asset_id' => :'String',
+        :'id' => :'String',
+        :'policy_id' => :'String',
+        :'time_created' => :'DateTime'
+      }
+    end
+  end
+end

data/lib/oci/core/models/volume_backup_schedule.rb

@@ -0,0 +1,191 @@
+# Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  # Defines a chronological recurrence pattern for creating scheduled backups at a particular periodicity.
+  class Core::Models::VolumeBackupSchedule
+
+    BACKUP_TYPE_ENUM = [BACKUP_TYPE_FULL = 'FULL',
+                BACKUP_TYPE_INCREMENTAL = 'INCREMENTAL',
+                BACKUP_TYPE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+
+    PERIOD_ENUM = [PERIOD_ONE_HOUR = 'ONE_HOUR',
+                PERIOD_ONE_DAY = 'ONE_DAY',
+                PERIOD_ONE_WEEK = 'ONE_WEEK',
+                PERIOD_ONE_MONTH = 'ONE_MONTH',
+                PERIOD_ONE_YEAR = 'ONE_YEAR',
+                PERIOD_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+    # **[Required]** The type of backup to create.
+    # @return [String]
+    attr_accessor :backup_type
+
+    # **[Required]** The number of seconds (positive or negative) that the backup time should be shifted from the default interval boundaries specified by the period.
+    # @return [Integer]
+    attr_accessor :offset_seconds
+
+    # **[Required]** How often the backup should occur.
+    # @return [String]
+    attr_accessor :period
+
+    # **[Required]** How long, in seconds, backups created by this schedule should be kept until being automatically deleted.
+    # @return [Integer]
+    attr_accessor :retention_seconds
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [String] :backupType The value to assign to the {#backup_type} property
+    # @option attributes [Integer] :offsetSeconds The value to assign to the {#offset_seconds} property
+    # @option attributes [String] :period The value to assign to the {#period} property
+    # @option attributes [Integer] :retentionSeconds The value to assign to the {#retention_seconds} 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}
+
+      if attributes[:'backupType']
+        self.backup_type = attributes[:'backupType']
+      end
+
+      if attributes[:'offsetSeconds']
+        self.offset_seconds = attributes[:'offsetSeconds']
+      end
+
+      if attributes[:'period']
+        self.period = attributes[:'period']
+      end
+
+      if attributes[:'retentionSeconds']
+        self.retention_seconds = attributes[:'retentionSeconds']
+      end
+
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] backup_type Object to be assigned
+    def backup_type=(backup_type)
+      if backup_type && !BACKUP_TYPE_ENUM.include?(backup_type)
+        @backup_type = BACKUP_TYPE_UNKNOWN_ENUM_VALUE
+      else
+        @backup_type = backup_type
+      end
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] period Object to be assigned
+    def period=(period)
+      if period && !PERIOD_ENUM.include?(period)
+        @period = PERIOD_UNKNOWN_ENUM_VALUE
+      else
+        @period = period
+      end
+    end
+
+    # 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 &&
+          backup_type == other_object.backup_type &&
+          offset_seconds == other_object.offset_seconds &&
+          period == other_object.period &&
+          retention_seconds == other_object.retention_seconds
+    end
+
+    # @see the `==` method
+    # @param [Object] other_object to be compared
+    def eql?(other_object)
+      self == other_object
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [backup_type, offset_seconds, period, retention_seconds].hash
+    end
+
+    # 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)
+            self.public_method("#{key}=").call(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.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
+
+    # 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
+
+
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      { 
+        :'backup_type' => :'backupType',
+        :'offset_seconds' => :'offsetSeconds',
+        :'period' => :'period',
+        :'retention_seconds' => :'retentionSeconds'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'backup_type' => :'String',
+        :'offset_seconds' => :'Integer',
+        :'period' => :'String',
+        :'retention_seconds' => :'Integer'
+      }
+    end
+  end
+end

data/lib/oci/core/virtual_network_client.rb

@@ -699,6 +699,64 @@ module OCI
         :return_type => 'OCI::Core::Models::PrivateIp')
     end
 
+    # Creates a public IP. Use the `lifetime` property to specify whether it's an ephemeral or
+    # reserved public IP. For information about limits on how many you can create, see
+    # [Public IP Addresses](https://docs.us-phoenix-1.oraclecloud.com/Content/Network/Tasks/managingpublicIPs.htm).
+    # 
+    # * **For an ephemeral public IP:** You must also specify a `privateIpId` with the OCID of
+    # the primary private IP you want to assign the public IP to. The public IP is created in
+    # the same Availability Domain as the private IP. An ephemeral public IP must always be
+    # assigned to a private IP, and only to the *primary* private IP on a VNIC, not a secondary
+    # private IP.
+    # 
+    # * **For a reserved public IP:** You may also optionally assign the public IP to a private
+    # IP by specifying `privateIpId`. Or you can later assign the public IP with
+    # {#update_public_ip update_public_ip}.
+    # 
+    # **Note:** When assigning a public IP to a private IP, the private IP must not already have
+    # a public IP with `lifecycleState` = ASSIGNING or ASSIGNED. If it does, an error is returned.
+    # 
+    # Also, for reserved public IPs, the optional assignment part of this operation is
+    # asynchronous. Poll the public IP's `lifecycleState` to determine if the assignment
+    # succeeded.
+    # 
+    # @param [CreatePublicIpDetails] create_public_ip_details Create public IP details.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :opc_retry_token A token that uniquely identifies a request so it can be retried in case of a timeout or
+    #   server error without risk of executing that same action again. Retry tokens expire after 24
+    #   hours, but can be invalidated before then due to conflicting operations (for example, if a resource
+    #   has been deleted and purged from the system, then a retry of the original creation request
+    #   may be rejected).
+    #   
+    # @return [Response] A Response object with data of type OCI::Core::Models::PublicIp
+    def create_public_ip(create_public_ip_details, opts = {})
+      logger.debug "Calling operation VirtualNetworkClient#create_public_ip." if logger
+
+      fail "Missing the required parameter 'create_public_ip_details' when calling create_public_ip." if create_public_ip_details.nil?
+
+      path = "/publicIps"
+
+      # Query Params
+      query_params = {}
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+      header_params[:'opc-retry-token'] = opts[:'opc_retry_token'] if opts[:'opc_retry_token']
+
+      post_body = @api_client.object_to_http_body(create_public_ip_details)
+
+      return @api_client.call_api(
+        :POST,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :return_type => 'OCI::Core::Models::PublicIp')
+    end
+
     # Creates a new route table for the specified VCN. In the request you must also include at least one route
     # rule for the new route table. For information on the number of rules you can have in a route table, see
     # [Service Limits](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/servicelimits.htm). For general information about route
@@ -1363,7 +1421,7 @@ module OCI
     # unassigning it from the VNIC causes that route rule to blackhole and the traffic
     # will be dropped.
     # 
-    # @param [String] private_ip_id The private IP's OCID.
+    # @param [String] private_ip_id The OCID of the private IP.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :if_match For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
     #   parameter to the value of the etag from a previous GET or POST response for that resource.  The resource
@@ -1397,6 +1455,52 @@ module OCI
         :body => post_body)
     end
 
+    # Unassigns and deletes the specified public IP (either ephemeral or reserved).
+    # You must specify the object's OCID. The public IP address is returned to the
+    # Oracle Cloud Infrastructure public IP pool.
+    # 
+    # For an assigned reserved public IP, the initial unassignment portion of this operation
+    # is asynchronous. Poll the public IP's `lifecycleState` to determine
+    # if the operation succeeded.
+    # 
+    # If you want to simply unassign a reserved public IP and return it to your pool
+    # of reserved public IPs, instead use
+    # {#update_public_ip update_public_ip}.
+    # 
+    # @param [String] public_ip_id The OCID of the public IP.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :if_match For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
+    #   parameter to the value of the etag from a previous GET or POST response for that resource.  The resource
+    #   will be updated or deleted only if the etag you provide matches the resource's current etag value.
+    #   
+    # @return [Response] A Response object with data of type nil
+    def delete_public_ip(public_ip_id, opts = {})
+      logger.debug "Calling operation VirtualNetworkClient#delete_public_ip." if logger
+
+      fail "Missing the required parameter 'public_ip_id' when calling delete_public_ip." if public_ip_id.nil?
+
+      path = "/publicIps/{publicIpId}".sub('{publicIpId}', public_ip_id.to_s)
+
+      # Query Params
+      query_params = {}
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+      header_params[:'if-match'] = opts[:'if_match'] if opts[:'if_match']
+
+      post_body = nil
+
+      return @api_client.call_api(
+        :DELETE,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body)
+    end
+
     # Deletes the specified route table, but only if it's not associated with a subnet. You can't delete a
     # VCN's default route table.
     # 
@@ -2041,7 +2145,7 @@ module OCI
     # {#list_private_ips list_private_ips}
     # with the private IP address (for example, 10.0.3.3) and subnet OCID.
     # 
-    # @param [String] private_ip_id The private IP's OCID.
+    # @param [String] private_ip_id The OCID of the private IP.
     # @param [Hash] opts the optional parameters
     # @return [Response] A Response object with data of type OCI::Core::Models::PrivateIp
     def get_private_ip(private_ip_id, opts = {})
@@ -2071,6 +2175,126 @@ module OCI
         :return_type => 'OCI::Core::Models::PrivateIp')
     end
 
+    # Gets the specified public IP. You must specify the object's OCID.
+    # 
+    # Alternatively, you can get the object by using {#get_public_ip_by_ip_address get_public_ip_by_ip_address}
+    # with the public IP address (for example, 129.146.2.1).
+    # 
+    # Or you can use {#get_public_ip_by_private_ip_id get_public_ip_by_private_ip_id}
+    # with the OCID of the private IP that the public IP is assigned to.
+    # 
+    # **Note:** If you're fetching a reserved public IP that is in the process of being
+    # moved to a different private IP, the service returns the public IP object with
+    # `lifecycleState` = ASSIGNING and `privateIpId` = OCID of the target private IP.
+    # 
+    # @param [String] public_ip_id The OCID of the public IP.
+    # @param [Hash] opts the optional parameters
+    # @return [Response] A Response object with data of type OCI::Core::Models::PublicIp
+    def get_public_ip(public_ip_id, opts = {})
+      logger.debug "Calling operation VirtualNetworkClient#get_public_ip." if logger
+
+      fail "Missing the required parameter 'public_ip_id' when calling get_public_ip." if public_ip_id.nil?
+
+      path = "/publicIps/{publicIpId}".sub('{publicIpId}', public_ip_id.to_s)
+
+      # Query Params
+      query_params = {}
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+
+      post_body = nil
+
+      return @api_client.call_api(
+        :GET,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :return_type => 'OCI::Core::Models::PublicIp')
+    end
+
+    # Gets the public IP based on the public IP address (for example, 129.146.2.1).
+    # 
+    # **Note:** If you're fetching a reserved public IP that is in the process of being
+    # moved to a different private IP, the service returns the public IP object with
+    # `lifecycleState` = ASSIGNING and `privateIpId` = OCID of the target private IP.
+    # 
+    # @param [GetPublicIpByIpAddressDetails] get_public_ip_by_ip_address_details IP address details for fetching the public IP.
+    # @param [Hash] opts the optional parameters
+    # @return [Response] A Response object with data of type OCI::Core::Models::PublicIp
+    def get_public_ip_by_ip_address(get_public_ip_by_ip_address_details, opts = {})
+      logger.debug "Calling operation VirtualNetworkClient#get_public_ip_by_ip_address." if logger
+
+      fail "Missing the required parameter 'get_public_ip_by_ip_address_details' when calling get_public_ip_by_ip_address." if get_public_ip_by_ip_address_details.nil?
+
+      path = "/publicIps/actions/getByIpAddress"
+
+      # Query Params
+      query_params = {}
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+
+      post_body = @api_client.object_to_http_body(get_public_ip_by_ip_address_details)
+
+      return @api_client.call_api(
+        :POST,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :return_type => 'OCI::Core::Models::PublicIp')
+    end
+
+    # Gets the public IP assigned to the specified private IP. You must specify the OCID
+    # of the private IP. If no public IP is assigned, a 404 is returned.
+    # 
+    # **Note:** If you're fetching a reserved public IP that is in the process of being
+    # moved to a different private IP, and you provide the OCID of the original private
+    # IP, this operation returns a 404. If you instead provide the OCID of the target
+    # private IP, or if you instead call
+    # {#get_public_ip get_public_ip} or
+    # {#get_public_ip_by_ip_address get_public_ip_by_ip_address}, the
+    # service returns the public IP object with `lifecycleState` = ASSIGNING and `privateIpId` = OCID
+    # of the target private IP.
+    # 
+    # @param [GetPublicIpByPrivateIpIdDetails] get_public_ip_by_private_ip_id_details Private IP details for fetching the public IP.
+    # @param [Hash] opts the optional parameters
+    # @return [Response] A Response object with data of type OCI::Core::Models::PublicIp
+    def get_public_ip_by_private_ip_id(get_public_ip_by_private_ip_id_details, opts = {})
+      logger.debug "Calling operation VirtualNetworkClient#get_public_ip_by_private_ip_id." if logger
+
+      fail "Missing the required parameter 'get_public_ip_by_private_ip_id_details' when calling get_public_ip_by_private_ip_id." if get_public_ip_by_private_ip_id_details.nil?
+
+      path = "/publicIps/actions/getByPrivateIpId"
+
+      # Query Params
+      query_params = {}
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+
+      post_body = @api_client.object_to_http_body(get_public_ip_by_private_ip_id_details)
+
+      return @api_client.call_api(
+        :POST,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :return_type => 'OCI::Core::Models::PublicIp')
+    end
+
     # Gets the specified route table's information.
     # @param [String] rt_id The OCID of the route table.
     # @param [Hash] opts the optional parameters
@@ -2987,7 +3211,7 @@ module OCI
     #   
     # @option opts [String] :page The value of the `opc-next-page` response header from the previous \"List\" call.
     #   
-    # @option opts [String] :ip_address The private IP address of the `privateIp` object.
+    # @option opts [String] :ip_address An IP address.
     #   
     #   Example: `10.0.3.3`
     #   
@@ -3025,6 +3249,75 @@ module OCI
         :return_type => 'Array<OCI::Core::Models::PrivateIp>')
     end
 
+    # Lists either the ephemeral or reserved {PublicIp} objects
+    # in the specified compartment.
+    # 
+    # To list your reserved public IPs, set `scope` = `REGION`, and leave the
+    # `availabilityDomain` parameter empty.
+    # 
+    # To list your ephemeral public IPs, set `scope` = `AVAILABILITY_DOMAIN`, and set the
+    # `availabilityDomain` parameter to the desired Availability Domain. An ephemeral public IP
+    # is always in the same Availability Domain and compartment as the private IP it's assigned to.
+    # 
+    # @param [String] scope Whether the public IP is regional or specific to a particular Availability Domain.
+    #   
+    #   * `REGION`: The public IP exists within a region and can be assigned to a private IP
+    #   in any Availability Domain in the region. Reserved public IPs have `scope` = `REGION`.
+    #   
+    #   * `AVAILABILITY_DOMAIN`: The public IP exists within the Availability Domain of the private IP
+    #   it's assigned to, which is specified by the `availabilityDomain` property of the public IP object.
+    #   Ephemeral public IPs have `scope` = `AVAILABILITY_DOMAIN`.
+    #   
+    #   Allowed values are: REGION, AVAILABILITY_DOMAIN
+    # @param [String] compartment_id The OCID of the compartment.
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :limit The maximum number of items to return in a paginated \"List\" call.
+    #   
+    #   Example: `500`
+    #   
+    # @option opts [String] :page The value of the `opc-next-page` response header from the previous \"List\" call.
+    #   
+    # @option opts [String] :availability_domain The name of the Availability Domain.
+    #   
+    #   Example: `Uocm:PHX-AD-1`
+    #   
+    # @return [Response] A Response object with data of type Array<OCI::Core::Models::PublicIp>
+    def list_public_ips(scope, compartment_id, opts = {})
+      logger.debug "Calling operation VirtualNetworkClient#list_public_ips." if logger
+
+      fail "Missing the required parameter 'scope' when calling list_public_ips." if scope.nil?
+      unless ['REGION', 'AVAILABILITY_DOMAIN'].include?(scope)
+        fail "Invalid value for 'scope', must be one of REGION, AVAILABILITY_DOMAIN."
+      end
+      fail "Missing the required parameter 'compartment_id' when calling list_public_ips." if compartment_id.nil?
+
+      path = "/publicIps"
+
+      # Query Params
+      query_params = {}
+      query_params[:'scope'] = scope
+      query_params[:'compartmentId'] = compartment_id
+      query_params[:'limit'] = opts[:'limit'] if opts[:'limit']
+      query_params[:'page'] = opts[:'page'] if opts[:'page']
+      query_params[:'availabilityDomain'] = opts[:'availability_domain'] if opts[:'availability_domain']
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+
+      post_body = nil
+
+      return @api_client.call_api(
+        :GET,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :return_type => 'Array<OCI::Core::Models::PublicIp>')
+    end
+
     # Lists the route tables in the specified VCN and specified compartment. The response
     # includes the default route table that automatically comes with each VCN, plus any route tables
     # you've created.
@@ -3865,7 +4158,7 @@ module OCI
     # To update the hostname for the primary IP on a VNIC, use
     # {#update_vnic update_vnic}.
     # 
-    # @param [String] private_ip_id The private IP's OCID.
+    # @param [String] private_ip_id The OCID of the private IP.
     # @param [UpdatePrivateIpDetails] update_private_ip_details Private IP details.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :if_match For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
@@ -3902,6 +4195,83 @@ module OCI
         :return_type => 'OCI::Core::Models::PrivateIp')
     end
 
+    # Updates the specified public IP. You must specify the object's OCID. Use this operation if you want to:
+    # 
+    # * Assign a reserved public IP in your pool to a private IP.
+    # * Move a reserved public IP to a different private IP.
+    # * Unassign a reserved public IP from a private IP (which returns it to your pool
+    # of reserved public IPs).
+    # * Change the display name for a public IP (either ephemeral or reserved).
+    # 
+    # Assigning, moving, and unassigning a reserved public IP are asynchronous
+    # operations. Poll the public IP's `lifecycleState` to determine if the operation
+    # succeeded.
+    # 
+    # **Note:** When moving a reserved public IP, the target private IP
+    # must not already have a public IP with `lifecycleState` = ASSIGNING or ASSIGNED. If it
+    # does, an error is returned. Also, the initial unassignment from the original
+    # private IP always succeeds, but the assignment to the target private IP is asynchronous and
+    # could fail silently (for example, if the target private IP is deleted or has a different public IP
+    # assigned to it in the interim). If that occurs, the public IP remains unassigned and its
+    # `lifecycleState` switches to AVAILABLE (it is not reassigned to its original private IP).
+    # You must poll the public IP's `lifecycleState` to determine if the move succeeded.
+    # 
+    # Regarding ephemeral public IPs:
+    # 
+    # * If you want to assign an ephemeral public IP to a primary private IP, use
+    # {#create_public_ip create_public_ip}.
+    # * You can't move an ephemeral public IP to a different private IP.
+    # * If you want to unassign an ephemeral public IP from its private IP, use
+    # {#delete_public_ip delete_public_ip}, which
+    # unassigns and deletes the ephemeral public IP.
+    # 
+    # **Note:** If a public IP (either ephemeral or reserved) is assigned to a secondary private
+    # IP (see {PrivateIp}), and you move that secondary
+    # private IP to another VNIC, the public IP moves with it.
+    # 
+    # **Note:** There's a limit to the number of {PublicIp}
+    # a VNIC or instance can have. If you try to move a reserved public IP
+    # to a VNIC or instance that has already reached its public IP limit, an error is
+    # returned. For information about the public IP limits, see
+    # [Public IP Addresses](https://docs.us-phoenix-1.oraclecloud.com/Content/Network/Tasks/managingpublicIPs.htm).
+    # 
+    # @param [String] public_ip_id The OCID of the public IP.
+    # @param [UpdatePublicIpDetails] update_public_ip_details Public IP details.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :if_match For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
+    #   parameter to the value of the etag from a previous GET or POST response for that resource.  The resource
+    #   will be updated or deleted only if the etag you provide matches the resource's current etag value.
+    #   
+    # @return [Response] A Response object with data of type OCI::Core::Models::PublicIp
+    def update_public_ip(public_ip_id, update_public_ip_details, opts = {})
+      logger.debug "Calling operation VirtualNetworkClient#update_public_ip." if logger
+
+      fail "Missing the required parameter 'public_ip_id' when calling update_public_ip." if public_ip_id.nil?
+      fail "Missing the required parameter 'update_public_ip_details' when calling update_public_ip." if update_public_ip_details.nil?
+
+      path = "/publicIps/{publicIpId}".sub('{publicIpId}', public_ip_id.to_s)
+
+      # Query Params
+      query_params = {}
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+      header_params[:'if-match'] = opts[:'if_match'] if opts[:'if_match']
+
+      post_body = @api_client.object_to_http_body(update_public_ip_details)
+
+      return @api_client.call_api(
+        :PUT,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :return_type => 'OCI::Core::Models::PublicIp')
+    end
+
     # Updates the specified route table's display name or route rules.
     # Avoid entering confidential information.
     #