twilio-ruby 7.9.1 → 7.10.0

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

@@ -29,6 +29,7 @@ module Twilio
                     # @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"
@@ -67,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.
@@ -106,6 +146,28 @@ module Twilio
                         @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
                     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
+
                     ##
                     # When passed a block, yields IpAddressInstance records from the API.
                     # This operation lazily loads records as efficiently as possible until the limit
@@ -127,7 +189,7 @@ 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,
@@ -174,6 +236,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,  }
@@ -190,9 +253,29 @@ module Twilio
                         
                         
                         
+
                         @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
+
                     ##
                     # Fetch the IpAddressInstance
                     # @return [IpAddressInstance] Fetched IpAddressInstance
@@ -214,6 +297,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.
@@ -248,6 +358,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
@@ -264,6 +414,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
@@ -273,6 +470,7 @@ module Twilio
                     # @return [IpAddressPage] IpAddressPage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -292,6 +490,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
@@ -305,6 +563,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'],

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

@@ -28,6 +28,7 @@ module Twilio
                     # @return [IpAccessControlListList] IpAccessControlListList
                     def initialize(version, account_sid: nil)
                         super(version)
+                        
                         # Path Solution
                         @solution = { account_sid: account_sid }
                         @uri = "/Accounts/#{@solution[:account_sid]}/SIP/IpAccessControlLists.json"
@@ -59,6 +60,38 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Create the IpAccessControlListInstanceMetadata
+                    # @param [String] friendly_name A human readable descriptive text that describes the IpAccessControlList, up to 255 characters long.
+                    # @return [IpAccessControlListInstance] Created IpAccessControlListInstance
+                    def create_with_metadata(
+                      friendly_name: nil
+                    )
+
+                        data = Twilio::Values.of({
+                            'FriendlyName' => friendly_name,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, data: data, headers: headers)
+                        ip_access_control_list_instance = IpAccessControlListInstance.new(
+                            @version,
+                            response.body,
+                            account_sid: @solution[:account_sid],
+                        )
+                        IpAccessControlListInstanceMetadata.new(
+                            @version,
+                            ip_access_control_list_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                 
                     ##
                     # Lists IpAccessControlListInstance records from the API as a list.
@@ -98,6 +131,28 @@ module Twilio
                         @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
                     end
 
+                    ##
+                    # Lists IpAccessControlListPageMetadata 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)
+
+                        IpAccessControlListPageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
                     ##
                     # When passed a block, yields IpAccessControlListInstance records from the API.
                     # This operation lazily loads records as efficiently as possible until the limit
@@ -119,7 +174,7 @@ 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 IpAccessControlListInstance
-                    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,
@@ -165,6 +220,7 @@ module Twilio
                     # @return [IpAccessControlListContext] IpAccessControlListContext
                     def initialize(version, account_sid, sid)
                         super(version)
+                        
 
                         # Path Solution
                         @solution = { account_sid: account_sid, sid: sid,  }
@@ -182,9 +238,29 @@ module Twilio
                         
                         
                         
+
                         @version.delete('DELETE', @uri, headers: headers)
                     end
 
+                    ##
+                    # Delete the IpAccessControlListInstanceMetadata
+                    # @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)
+                          ipAccessControlList_instance = IpAccessControlListInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          IpAccessControlListInstanceMetadata.new(@version, ipAccessControlList_instance, response.headers, response.status_code)
+                    end
+
                     ##
                     # Fetch the IpAccessControlListInstance
                     # @return [IpAccessControlListInstance] Fetched IpAccessControlListInstance
@@ -205,6 +281,32 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Fetch the IpAccessControlListInstanceMetadata
+                    # @return [IpAccessControlListInstance] Fetched IpAccessControlListInstance
+                    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_access_control_list_instance = IpAccessControlListInstance.new(
+                            @version,
+                            response.body,
+                            account_sid: @solution[:account_sid],
+                            sid: @solution[:sid],
+                        )
+                        IpAccessControlListInstanceMetadata.new(
+                            @version,
+                            ip_access_control_list_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Update the IpAccessControlListInstance
                     # @param [String] friendly_name A human readable descriptive text, up to 255 characters long.
@@ -232,6 +334,39 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Update the IpAccessControlListInstanceMetadata
+                    # @param [String] friendly_name A human readable descriptive text, up to 255 characters long.
+                    # @return [IpAccessControlListInstance] Updated IpAccessControlListInstance
+                    def update_with_metadata(
+                      friendly_name: nil
+                    )
+
+                        data = Twilio::Values.of({
+                            'FriendlyName' => friendly_name,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('POST', @uri, data: data, headers: headers)
+                        ip_access_control_list_instance = IpAccessControlListInstance.new(
+                            @version,
+                            response.body,
+                            account_sid: @solution[:account_sid],
+                            sid: @solution[:sid],
+                        )
+                        IpAccessControlListInstanceMetadata.new(
+                            @version,
+                            ip_access_control_list_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Access the ip_addresses
                     # @return [IpAddressList]
@@ -267,6 +402,53 @@ module Twilio
                     end
                 end
 
+                class IpAccessControlListInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new IpAccessControlListInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}IpAccessControlListInstance] ip_access_control_list_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 [IpAccessControlListInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, ip_access_control_list_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @ip_access_control_list_instance = ip_access_control_list_instance
+                    end
+
+                    def ip_access_control_list
+                        @ip_access_control_list_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.IpAccessControlListInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class IpAccessControlListListResponse < InstanceListResource
+                    # @param [Array<IpAccessControlListInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @ip_access_control_list_instance = payload.body[key].map do |data|
+                        IpAccessControlListInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def ip_access_control_list_instance
+                          @instance
+                      end
+                  end
+
                 class IpAccessControlListPage < Page
                     ##
                     # Initialize the IpAccessControlListPage
@@ -276,6 +458,7 @@ module Twilio
                     # @return [IpAccessControlListPage] IpAccessControlListPage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -295,6 +478,66 @@ module Twilio
                         '<Twilio.Api.V2010.IpAccessControlListPage>'
                     end
                 end
+
+                class IpAccessControlListPageMetadata < PageMetadata
+                    attr_reader :ip_access_control_list_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @ip_access_control_list_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @ip_access_control_list_page << IpAccessControlListListResponse.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_access_control_list_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Api::V2010PageMetadata>';
+                    end
+                end
+                class IpAccessControlListListResponse < InstanceListResource
+
+                    # @param [Array<IpAccessControlListInstance>] 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_access_control_list = data_list.map do |data|
+                        IpAccessControlListInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def ip_access_control_list
+                        @ip_access_control_list
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class IpAccessControlListInstance < InstanceResource
                     ##
                     # Initialize the IpAccessControlListInstance
@@ -308,6 +551,7 @@ module Twilio
                     def initialize(version, payload , account_sid: nil, sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'sid' => payload['sid'],