twilio-ruby 7.10.7 → 7.11.2

data/lib/twilio-ruby/rest/lookups/v2/rate_limit.rb

@@ -124,65 +124,6 @@ module Twilio
                     end
                 end
 
-                class RateLimitPageMetadata < PageMetadata
-                    attr_reader :rate_limit_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @rate_limit_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @rate_limit_page << RateLimitListResponse.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
-                        @rate_limit_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Lookups::V2PageMetadata>';
-                    end
-                end
-                class RateLimitListResponse < InstanceListResource
-
-                    # @param [Array<RateLimitInstance>] 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
-                      @rate_limit = data_list.map do |data|
-                        RateLimitInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def rate_limit
-                        @rate_limit
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class RateLimitInstance < InstanceResource
                     ##
                     # Initialize the RateLimitInstance

data/lib/twilio-ruby/rest/marketplace/v1/installed_add_on/installed_add_on_usage.rb

@@ -137,65 +137,6 @@ module Twilio
                     end
                 end
 
-                class InstalledAddOnUsagePageMetadata < PageMetadata
-                    attr_reader :installed_add_on_usage_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @installed_add_on_usage_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @installed_add_on_usage_page << InstalledAddOnUsageListResponse.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
-                        @installed_add_on_usage_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Marketplace::V1PageMetadata>';
-                    end
-                end
-                class InstalledAddOnUsageListResponse < InstanceListResource
-
-                    # @param [Array<InstalledAddOnUsageInstance>] 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
-                      @installed_add_on_usage = data_list.map do |data|
-                        InstalledAddOnUsageInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def installed_add_on_usage
-                        @installed_add_on_usage
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class InstalledAddOnUsageInstance < InstanceResource
                     ##
                     # Initialize the InstalledAddOnUsageInstance

data/lib/twilio-ruby/rest/marketplace/v1/module_data.rb

@@ -174,65 +174,6 @@ module Twilio
                     end
                 end
 
-                class ModuleDataPageMetadata < PageMetadata
-                    attr_reader :module_data_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @module_data_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @module_data_page << ModuleDataListResponse.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
-                        @module_data_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Marketplace::V1PageMetadata>';
-                    end
-                end
-                class ModuleDataListResponse < InstanceListResource
-
-                    # @param [Array<ModuleDataInstance>] 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
-                      @module_data = data_list.map do |data|
-                        ModuleDataInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def module_data
-                        @module_data
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ModuleDataInstance < InstanceResource
                     ##
                     # Initialize the ModuleDataInstance

data/lib/twilio-ruby/rest/marketplace/v1/module_data_management.rb

@@ -288,65 +288,6 @@ module Twilio
                     end
                 end
 
-                class ModuleDataManagementPageMetadata < PageMetadata
-                    attr_reader :module_data_management_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @module_data_management_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @module_data_management_page << ModuleDataManagementListResponse.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
-                        @module_data_management_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Marketplace::V1PageMetadata>';
-                    end
-                end
-                class ModuleDataManagementListResponse < InstanceListResource
-
-                    # @param [Array<ModuleDataManagementInstance>] 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
-                      @module_data_management = data_list.map do |data|
-                        ModuleDataManagementInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def module_data_management
-                        @module_data_management
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ModuleDataManagementInstance < InstanceResource
                     ##
                     # Initialize the ModuleDataManagementInstance

data/lib/twilio-ruby/rest/marketplace/v1/referral_conversion.rb

@@ -130,65 +130,6 @@ module Twilio
                     end
                 end
 
-                class ReferralConversionPageMetadata < PageMetadata
-                    attr_reader :referral_conversion_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @referral_conversion_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @referral_conversion_page << ReferralConversionListResponse.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
-                        @referral_conversion_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Marketplace::V1PageMetadata>';
-                    end
-                end
-                class ReferralConversionListResponse < InstanceListResource
-
-                    # @param [Array<ReferralConversionInstance>] 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
-                      @referral_conversion = data_list.map do |data|
-                        ReferralConversionInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def referral_conversion
-                        @referral_conversion
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ReferralConversionInstance < InstanceResource
                     ##
                     # Initialize the ReferralConversionInstance

data/lib/twilio-ruby/rest/memory/v1/bulk.rb

@@ -5,7 +5,7 @@
 #     |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
 #
 #    Twilio Memory API
-#    APIs for managing memory stores, profiles, events, and conversational intelligence capabilities.
+#    APIs for managing memory stores, profiles, and conversational intelligence capabilities.
 #
 #    NOTE: This class is auto generated by OpenAPI Generator.
 #    https://openapi-generator.tech
@@ -50,40 +50,13 @@ module Twilio
                     # Initialize the BulkList
                     # @param [Version] version Version that contains the resource
                     # @return [BulkList] BulkList
-                    def initialize(version)
+                    def initialize(version, store_id: nil)
                         
                         apiV1Version = ApiV1Version.new version.domain, version
                         super(apiV1Version)
                         # Path Solution
-                        @solution = {  }
-                        
-                        
-                    end
-                
-
-
-                    # Provide a user friendly representation
-                    def to_s
-                        '#<Twilio.Memory.V1.BulkList>'
-                    end
-                end
-
-
-                class BulkContext < InstanceContext
-                    ##
-                    # Initialize the BulkContext
-                    # @param [Version] version Version that contains the resource
-                    # @param [String] store_id A unique Memory Store ID using Twilio Type ID (TTID) format
-                    # @return [BulkContext] BulkContext
-                    def initialize(version, store_id)
-                        
-                        apiV1Version = ApiV1Version.new version.domain, version
-                        super(apiV1Version)
-
-                        # Path Solution
-                        @solution = { store_id: store_id,  }
+                        @solution = { store_id: store_id }
                         @uri = "/Stores/#{@solution[:store_id]}/Profiles/Bulk"
-
                         
                     end
                     ##
@@ -134,69 +107,15 @@ module Twilio
                         )
                     end
 
+                
 
-                    ##
-                    # Provide a user friendly representation
-                    def to_s
-                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
-                        "#<Twilio.Memory.V1.BulkContext #{context}>"
-                    end
-
-                    ##
-                    # Provide a detailed, user friendly representation
-                    def inspect
-                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
-                        "#<Twilio.Memory.V1.BulkContext #{context}>"
-                    end
-                end
-
-                class BulkInstanceMetadata <  InstanceResourceMetadata
-                    ##
-                    # Initializes a new BulkInstanceMetadata.
-                    # @param [Version] version Version that contains the resource
-                    # @param [}BulkInstance] bulk_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 [BulkInstanceMetadata] The initialized instance with metadata.
-                    def initialize(version, bulk_instance, headers, status_code)
-                        super(version, headers, status_code)
-                        @bulk_instance = bulk_instance
-                    end
-
-                    def bulk
-                        @bulk_instance
-                    end
-
-                    def headers
-                        @headers
-                    end
-
-                    def status_code
-                        @status_code
-                    end
 
+                    # Provide a user friendly representation
                     def to_s
-                      "<Twilio.Api.V2010.BulkInstanceMetadata status=#{@status_code}>"
+                        '#<Twilio.Memory.V1.BulkList>'
                     end
                 end
 
-                class BulkListResponse < InstanceListResource
-                    # @param [Array<BulkInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key)
-                       @bulk_instance = payload.body[key].map do |data|
-                        BulkInstance.new(version, data)
-                       end
-                       @headers = payload.headers
-                       @status_code = payload.status_code
-                    end
-
-                      def bulk_instance
-                          @instance
-                      end
-                  end
-
                 class BulkPage < TokenPage
                     ##
                     # Initialize the BulkPage
@@ -218,7 +137,7 @@ module Twilio
                     # @param [Hash] payload Payload response from the API
                     # @return [BulkInstance] BulkInstance
                     def get_instance(payload)
-                        BulkInstance.new(@version, payload)
+                        BulkInstance.new(@version, payload, store_id: @solution[:store_id])
                     end
 
                     ##
@@ -228,65 +147,6 @@ module Twilio
                     end
                 end
 
-                class BulkPageMetadata < PageMetadata
-                    attr_reader :bulk_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @bulk_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @bulk_page << BulkListResponse.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
-                        @bulk_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Memory::V1PageMetadata>';
-                    end
-                end
-                class BulkListResponse < InstanceListResource
-
-                    # @param [Array<BulkInstance>] 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
-                      @bulk = data_list.map do |data|
-                        BulkInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def bulk
-                        @bulk
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class BulkInstance < InstanceResource
                     ##
                     # Initialize the BulkInstance
@@ -306,22 +166,8 @@ module Twilio
                         @properties = { 
                             'message' => payload['message'],
                         }
-
-                        # Context
-                        @instance_context = nil
-                        @params = { 'store_id' => store_id  || @properties['store_id']  , }
                     end
 
-                    ##
-                    # Generate an instance context for the instance, the context is capable of
-                    # performing various actions.  All instance actions are proxied to the context
-                    # @return [BulkContext] CallContext for this CallInstance
-                    def context
-                        unless @instance_context
-                            @instance_context = BulkContext.new(@version , @params['store_id'])
-                        end
-                        @instance_context
-                    end
                     
                     ##
                     # @return [String] 
@@ -329,30 +175,16 @@ module Twilio
                         @properties['message']
                     end
                     
-                    ##
-                    # Update the BulkInstance
-                    # @param [UpdateProfilesBulkRequest] update_profiles_bulk_request 
-                    # @return [BulkInstance] Updated BulkInstance
-                    def update(update_profiles_bulk_request: nil
-                    )
-
-                        context.update(
-                            update_profiles_bulk_request: update_profiles_bulk_request, 
-                        )
-                    end
-
                     ##
                     # Provide a user friendly representation
                     def to_s
-                        values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
-                        "<Twilio.Memory.V1.BulkInstance #{values}>"
+                        "<Twilio.Memory.V1.BulkInstance>"
                     end
 
                     ##
                     # Provide a detailed, user friendly representation
                     def inspect
-                        values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
-                        "<Twilio.Memory.V1.BulkInstance #{values}>"
+                        "<Twilio.Memory.V1.BulkInstance>"
                     end
                 end
 

data/lib/twilio-ruby/rest/memory/v1/conversation_summary.rb

@@ -5,7 +5,7 @@
 #     |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
 #
 #    Twilio Memory API
-#    APIs for managing memory stores, profiles, events, and conversational intelligence capabilities.
+#    APIs for managing memory stores, profiles, and conversational intelligence capabilities.
 #
 #    NOTE: This class is auto generated by OpenAPI Generator.
 #    https://openapi-generator.tech
@@ -214,6 +214,7 @@ module Twilio
                     # Unlike stream(), this operation is eager and will load `limit` records into
                     # memory before returning.
                     # @param [String] page_token The token for the page of results to retrieve.
+                    # @param [String] conversation_id Filter by conversation ID. Returns only items associated with the specified conversation.
                     # @param [String] accept_encoding Compression algorithms supported by the client (e.g., gzip, deflate, br)
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
@@ -222,9 +223,10 @@ module Twilio
                     #    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(page_token: :unset, accept_encoding: :unset, limit: nil, page_size: nil)
+                    def list(page_token: :unset, conversation_id: :unset, accept_encoding: :unset, limit: nil, page_size: nil)
                         self.stream(
                             page_token: page_token,
+                            conversation_id: conversation_id,
                             accept_encoding: accept_encoding,
                             limit: limit,
                             page_size: page_size
@@ -236,6 +238,7 @@ module Twilio
                     # This operation lazily loads records as efficiently as possible until the limit
                     # is reached.
                     # @param [String] page_token The token for the page of results to retrieve.
+                    # @param [String] conversation_id Filter by conversation ID. Returns only items associated with the specified conversation.
                     # @param [String] accept_encoding Compression algorithms supported by the client (e.g., gzip, deflate, br)
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
@@ -244,11 +247,12 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Enumerable] Enumerable that will yield up to limit results
-                    def stream(page_token: :unset, accept_encoding: :unset, limit: nil, page_size: nil)
+                    def stream(page_token: :unset, conversation_id: :unset, accept_encoding: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
 
                         page = self.page(
                             page_token: page_token,
+                            conversation_id: conversation_id,
                             accept_encoding: accept_encoding,
                             page_size: limits[:page_size], )
 
@@ -262,6 +266,7 @@ module Twilio
                     ##
                     # Lists ConversationSummaryPageMetadata records from the API as a list.
                       # @param [String] page_token The token for the page of results to retrieve.
+                      # @param [String] conversation_id Filter by conversation ID. Returns only items associated with the specified conversation.
                       # @param [String] accept_encoding Compression algorithms supported by the client (e.g., gzip, deflate, br)
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
@@ -270,15 +275,15 @@ module Twilio
                     #    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(page_token: :unset, accept_encoding: :unset, limit: nil, page_size: nil)
+                    def list_with_metadata(page_token: :unset, conversation_id: :unset, accept_encoding: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
                         params = Twilio::Values.of({
                             'pageToken' => page_token,
-                            'Accept-Encoding' => accept_encoding,
+                            'conversationId' => conversation_id,
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Accept-Encoding' => accept_encoding,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -307,16 +312,17 @@ module Twilio
                     # Retrieve a single page of ConversationSummaryInstance records from the API.
                     # Request is executed immediately.
                     # @param [String] page_token The token for the page of results to retrieve.
+                    # @param [String] conversation_id Filter by conversation ID. Returns only items associated with the specified conversation.
                     # @param [String] accept_encoding Compression algorithms supported by the client (e.g., gzip, deflate, br)
                     
                     # @return [Page] Page of ConversationSummaryInstance
-                    def page(page_token: :unset, accept_encoding: :unset, page_size: :unset)
+                    def page(page_token: :unset, conversation_id: :unset, accept_encoding: :unset, page_size: :unset)
                         params = Twilio::Values.of({
                             'pageToken' => page_token,
-                            'Accept-Encoding' => accept_encoding,
+                            'conversationId' => conversation_id,
                                                         'PageSize' => page_size,
                         })
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Accept-Encoding' => accept_encoding,  })