twilio-ruby 6.8.0 → 7.10.7

data/lib/twilio-ruby/rest/api/v2010/account/sip/ip_access_control_list/ip_address.rb

@@ -22,12 +22,14 @@ module Twilio
                 class IpAccessControlListContext < InstanceContext
 
                      class IpAddressList < ListResource
+                
                     ##
                     # Initialize the IpAddressList
                     # @param [Version] version Version that contains the resource
                     # @return [IpAddressList] IpAddressList
                     def initialize(version, account_sid: nil, ip_access_control_list_sid: nil)
                         super(version)
+                        
                         # Path Solution
                         @solution = { account_sid: account_sid, ip_access_control_list_sid: ip_access_control_list_sid }
                         @uri = "/Accounts/#{@solution[:account_sid]}/SIP/IpAccessControlLists/#{@solution[:ip_access_control_list_sid]}/IpAddresses.json"
@@ -40,9 +42,9 @@ module Twilio
                     # @param [String] cidr_prefix_length An integer representing the length of the CIDR prefix to use with this IP address when accepting traffic. By default the entire IP address is used.
                     # @return [IpAddressInstance] Created IpAddressInstance
                     def create(
-                        friendly_name: nil, 
-                        ip_address: nil, 
-                        cidr_prefix_length: :unset
+                      friendly_name: nil, 
+                      ip_address: nil, 
+                      cidr_prefix_length: :unset
                     )
 
                         data = Twilio::Values.of({
@@ -51,7 +53,13 @@ module Twilio
                             'CidrPrefixLength' => cidr_prefix_length,
                         })
 
-                        payload = @version.create('POST', @uri, data: data)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.create('POST', @uri, data: data, headers: headers)
                         IpAddressInstance.new(
                             @version,
                             payload,
@@ -60,6 +68,45 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Create the IpAddressInstanceMetadata
+                    # @param [String] friendly_name A human readable descriptive text for this resource, up to 255 characters long.
+                    # @param [String] ip_address An IP address in dotted decimal notation from which you want to accept traffic. Any SIP requests from this IP address will be allowed by Twilio. IPv4 only supported today.
+                    # @param [String] cidr_prefix_length An integer representing the length of the CIDR prefix to use with this IP address when accepting traffic. By default the entire IP address is used.
+                    # @return [IpAddressInstance] Created IpAddressInstance
+                    def create_with_metadata(
+                      friendly_name: nil, 
+                      ip_address: nil, 
+                      cidr_prefix_length: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'FriendlyName' => friendly_name,
+                            'IpAddress' => ip_address,
+                            'CidrPrefixLength' => cidr_prefix_length,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, data: data, headers: headers)
+                        ip_address_instance = IpAddressInstance.new(
+                            @version,
+                            response.body,
+                            account_sid: @solution[:account_sid],
+                            ip_access_control_list_sid: @solution[:ip_access_control_list_sid],
+                        )
+                        IpAddressInstanceMetadata.new(
+                            @version,
+                            ip_address_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                 
                     ##
                     # Lists IpAddressInstance records from the API as a list.
@@ -96,7 +143,33 @@ module Twilio
                         page = self.page(
                             page_size: limits[:page_size], )
 
-                        @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
+                        return [].each if page.nil?
+
+                        result = @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
+                        return [].each if result.nil?
+                        result
+                    end
+
+                    ##
+                    # Lists IpAddressPageMetadata records from the API as a list.
+                    # @param [Integer] limit Upper limit for the number of records to return. stream()
+                    #    guarantees to never return more than limit.  Default is no limit
+                    # @param [Integer] page_size Number of records to fetch per request, when
+                    #    not set will use the default value of 50 records.  If no page_size is defined
+                    #    but a limit is defined, stream() will attempt to read the limit with the most
+                    #    efficient page size, i.e. min(limit, 1000)
+                    # @return [Array] Array of up to limit results
+                    def list_with_metadata(limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        IpAddressPageMetadata.new(@version, response, @solution, limits[:limit])
                     end
 
                     ##
@@ -108,9 +181,13 @@ module Twilio
 
                         page = self.page(page_size: limits[:page_size], )
 
-                        @version.stream(page,
+                        return [].each if page.nil?
+
+                        result = @version.stream(page,
                             limit: limits[:limit],
-                            page_limit: limits[:page_limit]).each {|x| yield x}
+                            page_limit: limits[:page_limit])
+                        return [].each if result.nil?
+                        result.each {|x| yield x}
                     end
 
                     ##
@@ -120,14 +197,17 @@ module Twilio
                     # @param [Integer] page_number Page Number, this value is simply for client state
                     # @param [Integer] page_size Number of records to return, defaults to 50
                     # @return [Page] Page of IpAddressInstance
-                    def page(page_token: :unset, page_number: :unset, page_size: :unset)
+                    def page(page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
                             'PageToken' => page_token,
                             'Page' => page_number,
                             'PageSize' => page_size,
                         })
+                        headers = Twilio::Values.of({})
+                        
+                        
 
-                        response = @version.page('GET', @uri, params: params)
+                        response = @version.page('GET', @uri, params: params, headers: headers)
 
                         IpAddressPage.new(@version, response, @solution)
                     end
@@ -164,6 +244,7 @@ module Twilio
                     # @return [IpAddressContext] IpAddressContext
                     def initialize(version, account_sid, ip_access_control_list_sid, sid)
                         super(version)
+                        
 
                         # Path Solution
                         @solution = { account_sid: account_sid, ip_access_control_list_sid: ip_access_control_list_sid, sid: sid,  }
@@ -176,7 +257,31 @@ module Twilio
                     # @return [Boolean] True if delete succeeds, false otherwise
                     def delete
 
-                        @version.delete('DELETE', @uri)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+
+                        @version.delete('DELETE', @uri, headers: headers)
+                    end
+
+                    ##
+                    # Delete the IpAddressInstanceMetadata
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                          response = @version.delete_with_metadata('DELETE', @uri, headers: headers)
+                          ipAddress_instance = IpAddressInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          IpAddressInstanceMetadata.new(@version, ipAddress_instance, response.headers, response.status_code)
                     end
 
                     ##
@@ -184,7 +289,13 @@ module Twilio
                     # @return [IpAddressInstance] Fetched IpAddressInstance
                     def fetch
 
-                        payload = @version.fetch('GET', @uri)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.fetch('GET', @uri, headers: headers)
                         IpAddressInstance.new(
                             @version,
                             payload,
@@ -194,6 +305,33 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Fetch the IpAddressInstanceMetadata
+                    # @return [IpAddressInstance] Fetched IpAddressInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        ip_address_instance = IpAddressInstance.new(
+                            @version,
+                            response.body,
+                            account_sid: @solution[:account_sid],
+                            ip_access_control_list_sid: @solution[:ip_access_control_list_sid],
+                            sid: @solution[:sid],
+                        )
+                        IpAddressInstanceMetadata.new(
+                            @version,
+                            ip_address_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Update the IpAddressInstance
                     # @param [String] ip_address An IP address in dotted decimal notation from which you want to accept traffic. Any SIP requests from this IP address will be allowed by Twilio. IPv4 only supported today.
@@ -201,9 +339,9 @@ module Twilio
                     # @param [String] cidr_prefix_length An integer representing the length of the CIDR prefix to use with this IP address when accepting traffic. By default the entire IP address is used.
                     # @return [IpAddressInstance] Updated IpAddressInstance
                     def update(
-                        ip_address: :unset, 
-                        friendly_name: :unset, 
-                        cidr_prefix_length: :unset
+                      ip_address: :unset, 
+                      friendly_name: :unset, 
+                      cidr_prefix_length: :unset
                     )
 
                         data = Twilio::Values.of({
@@ -212,7 +350,13 @@ module Twilio
                             'CidrPrefixLength' => cidr_prefix_length,
                         })
 
-                        payload = @version.update('POST', @uri, data: data)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.update('POST', @uri, data: data, headers: headers)
                         IpAddressInstance.new(
                             @version,
                             payload,
@@ -222,6 +366,46 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Update the IpAddressInstanceMetadata
+                    # @param [String] ip_address An IP address in dotted decimal notation from which you want to accept traffic. Any SIP requests from this IP address will be allowed by Twilio. IPv4 only supported today.
+                    # @param [String] friendly_name A human readable descriptive text for this resource, up to 255 characters long.
+                    # @param [String] cidr_prefix_length An integer representing the length of the CIDR prefix to use with this IP address when accepting traffic. By default the entire IP address is used.
+                    # @return [IpAddressInstance] Updated IpAddressInstance
+                    def update_with_metadata(
+                      ip_address: :unset, 
+                      friendly_name: :unset, 
+                      cidr_prefix_length: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'IpAddress' => ip_address,
+                            'FriendlyName' => friendly_name,
+                            'CidrPrefixLength' => cidr_prefix_length,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('POST', @uri, data: data, headers: headers)
+                        ip_address_instance = IpAddressInstance.new(
+                            @version,
+                            response.body,
+                            account_sid: @solution[:account_sid],
+                            ip_access_control_list_sid: @solution[:ip_access_control_list_sid],
+                            sid: @solution[:sid],
+                        )
+                        IpAddressInstanceMetadata.new(
+                            @version,
+                            ip_address_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
 
                     ##
                     # Provide a user friendly representation
@@ -238,6 +422,53 @@ module Twilio
                     end
                 end
 
+                class IpAddressInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new IpAddressInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}IpAddressInstance] ip_address_instance The instance associated with the metadata.
+                    # @param [Hash] headers Header object with response headers.
+                    # @param [Integer] status_code The HTTP status code of the response.
+                    # @return [IpAddressInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, ip_address_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @ip_address_instance = ip_address_instance
+                    end
+
+                    def ip_address
+                        @ip_address_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.IpAddressInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class IpAddressListResponse < InstanceListResource
+                    # @param [Array<IpAddressInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @ip_address_instance = payload.body[key].map do |data|
+                        IpAddressInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def ip_address_instance
+                          @instance
+                      end
+                  end
+
                 class IpAddressPage < Page
                     ##
                     # Initialize the IpAddressPage
@@ -247,6 +478,7 @@ module Twilio
                     # @return [IpAddressPage] IpAddressPage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -266,6 +498,66 @@ module Twilio
                         '<Twilio.Api.V2010.IpAddressPage>'
                     end
                 end
+
+                class IpAddressPageMetadata < PageMetadata
+                    attr_reader :ip_address_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @ip_address_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @ip_address_page << IpAddressListResponse.new(version, @payload, key, limit - records)
+                            @payload = self.next_page
+                            break unless @payload
+                            records += (@payload.body[key] || []).size
+                        end
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    def each
+                        @ip_address_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Api::V2010PageMetadata>';
+                    end
+                end
+                class IpAddressListResponse < InstanceListResource
+
+                    # @param [Array<IpAddressInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key, limit = :unset)
+                      data_list = payload.body[key]  || []
+                      if limit != :unset
+                        data_list = data_list[0, limit]
+                      end
+                      @ip_address = data_list.map do |data|
+                        IpAddressInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def ip_address
+                        @ip_address
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class IpAddressInstance < InstanceResource
                     ##
                     # Initialize the IpAddressInstance
@@ -279,6 +571,7 @@ module Twilio
                     def initialize(version, payload , account_sid: nil, ip_access_control_list_sid: nil, sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'sid' => payload['sid'],
@@ -385,9 +678,9 @@ module Twilio
                     # @param [String] cidr_prefix_length An integer representing the length of the CIDR prefix to use with this IP address when accepting traffic. By default the entire IP address is used.
                     # @return [IpAddressInstance] Updated IpAddressInstance
                     def update(
-                        ip_address: :unset, 
-                        friendly_name: :unset, 
-                        cidr_prefix_length: :unset
+                      ip_address: :unset, 
+                      friendly_name: :unset, 
+                      cidr_prefix_length: :unset
                     )
 
                         context.update(