twilio-ruby 7.10.4 → 7.10.6

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

@@ -0,0 +1,843 @@
+##
+#    This code was generated by
+#    ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+#     |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+#     |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+#
+#    Twilio Memory API
+#    APIs for managing memory stores, profiles, events, and conversational intelligence capabilities.
+#
+#    NOTE: This class is auto generated by OpenAPI Generator.
+#    https://openapi-generator.tech
+#    Do not edit the class manually.
+#
+
+
+module Twilio
+    module REST
+        class Memory < MemoryBase
+            class V1 < Version
+                class DataMappingList < ListResource
+                
+                    class CreateDataMappingInput
+                            # @param [display_name]: [String] Name of the data mapping.
+                            # @param [description]: [String] A human readable description of this resource, up to 512 characters.
+                            # @param [is_enabled]: [Boolean] Flag indicating whether the data mapping is active. When true, data will be ingested and mapped according to the configuration. When false, the data mapping will be inactive and no data will be ingested into the Memory Store.
+                            # @param [mapping_to]: [DataMappingList.DataMappingToTraits] 
+                            # @param [mapping_from]: [DataMappingList.DataMappingFromDataSet] 
+                        attr_accessor :display_name, :description, :is_enabled, :mapping_to, :mapping_from
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                                @is_enabled = payload["is_enabled"]
+                                @mapping_to = payload["mapping_to"]
+                                @mapping_from = payload["mapping_from"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                                "isEnabled": @is_enabled,
+                                "mappingTo": @mapping_to,
+                                "mappingFrom": @mapping_from,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class DataMappingCore
+                            # @param [display_name]: [String] Name of the data mapping.
+                            # @param [description]: [String] A human readable description of this resource, up to 512 characters.
+                            # @param [is_enabled]: [Boolean] Flag indicating whether the data mapping is active. When true, data will be ingested and mapped according to the configuration. When false, the data mapping will be inactive and no data will be ingested into the Memory Store.
+                            # @param [mapping_to]: [DataMappingList.DataMappingToTraits] 
+                        attr_accessor :display_name, :description, :is_enabled, :mapping_to
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                                @is_enabled = payload["is_enabled"]
+                                @mapping_to = payload["mapping_to"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                                "isEnabled": @is_enabled,
+                                "mappingTo": @mapping_to,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class MappingTraitItem
+                            # @param [field_name]: [String] The name of the field/column in the source. Deprecated in favor of expression.
+                            # @param [expression]: [String] The expression identifying the field/column in the source.
+                            # @param [trait_group]: [String] The name of the Trait Group to map to.
+                            # @param [trait_name]: [String] The name of the trait within the Trait Group to map to.
+                        attr_accessor :field_name, :expression, :trait_group, :trait_name
+                        def initialize(payload)
+                                @field_name = payload["field_name"]
+                                @expression = payload["expression"]
+                                @trait_group = payload["trait_group"]
+                                @trait_name = payload["trait_name"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "fieldName": @field_name,
+                                "expression": @expression,
+                                "traitGroup": @trait_group,
+                                "traitName": @trait_name,
+                        }.to_json(options)
+                        end
+                    end
+
+
+                    class CreateDataMappingInput
+                            # @param [display_name]: [String] Name of the data mapping.
+                            # @param [description]: [String] A human readable description of this resource, up to 512 characters.
+                            # @param [is_enabled]: [Boolean] Flag indicating whether the data mapping is active. When true, data will be ingested and mapped according to the configuration. When false, the data mapping will be inactive and no data will be ingested into the Memory Store.
+                            # @param [mapping_to]: [DataMappingList.DataMappingToTraits] 
+                            # @param [mapping_from]: [DataMappingList.DataMappingFromDataSet] 
+                        attr_accessor :display_name, :description, :is_enabled, :mapping_to, :mapping_from
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                                @is_enabled = payload["is_enabled"]
+                                @mapping_to = payload["mapping_to"]
+                                @mapping_from = payload["mapping_from"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                                "isEnabled": @is_enabled,
+                                "mappingTo": @mapping_to,
+                                "mappingFrom": @mapping_from,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class DataMappingCore
+                            # @param [display_name]: [String] Name of the data mapping.
+                            # @param [description]: [String] A human readable description of this resource, up to 512 characters.
+                            # @param [is_enabled]: [Boolean] Flag indicating whether the data mapping is active. When true, data will be ingested and mapped according to the configuration. When false, the data mapping will be inactive and no data will be ingested into the Memory Store.
+                            # @param [mapping_to]: [DataMappingList.DataMappingToTraits] 
+                        attr_accessor :display_name, :description, :is_enabled, :mapping_to
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                                @is_enabled = payload["is_enabled"]
+                                @mapping_to = payload["mapping_to"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                                "isEnabled": @is_enabled,
+                                "mappingTo": @mapping_to,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class MappingTraitItem
+                            # @param [field_name]: [String] The name of the field/column in the source. Deprecated in favor of expression.
+                            # @param [expression]: [String] The expression identifying the field/column in the source.
+                            # @param [trait_group]: [String] The name of the Trait Group to map to.
+                            # @param [trait_name]: [String] The name of the trait within the Trait Group to map to.
+                        attr_accessor :field_name, :expression, :trait_group, :trait_name
+                        def initialize(payload)
+                                @field_name = payload["field_name"]
+                                @expression = payload["expression"]
+                                @trait_group = payload["trait_group"]
+                                @trait_name = payload["trait_name"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "fieldName": @field_name,
+                                "expression": @expression,
+                                "traitGroup": @trait_group,
+                                "traitName": @trait_name,
+                        }.to_json(options)
+                        end
+                    end
+
+
+                    ##
+                    # Initialize the DataMappingList
+                    # @param [Version] version Version that contains the resource
+                    # @return [DataMappingList] DataMappingList
+                    def initialize(version, store_id: nil)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+                        # Path Solution
+                        @solution = { store_id: store_id }
+                        @uri = "/ControlPlane/Stores/#{@solution[:store_id]}/DataMappings"
+                        
+                    end
+                    ##
+                    # Create the DataMappingInstance
+                    # @param [CreateDataMappingInput] create_data_mapping_input 
+                    # @return [DataMappingInstance] Created DataMappingInstance
+                    def create(create_data_mapping_input: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        payload = @version.create('POST', @uri, headers: headers, data: create_data_mapping_input.to_json)
+                        DataMappingInstance.new(
+                            @version,
+                            payload,
+                            store_id: @solution[:store_id],
+                        )
+                    end
+
+                    ##
+                    # Create the DataMappingInstanceMetadata
+                    # @param [CreateDataMappingInput] create_data_mapping_input 
+                    # @return [DataMappingInstance] Created DataMappingInstance
+                    def create_with_metadata(create_data_mapping_input: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, headers: headers, data: create_data_mapping_input.to_json)
+                        data_mapping_instance = DataMappingInstance.new(
+                            @version,
+                            response.body,
+                            store_id: @solution[:store_id],
+                        )
+                        DataMappingInstanceMetadata.new(
+                            @version,
+                            data_mapping_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+                
+                    ##
+                    # Lists DataMappingInstance records from the API as a list.
+                    # 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] order_by Either 'ASC' or 'DESC' to sort results ascending or descending respectively.
+                    # @param [DataMappingType] type Filter data mappings by type.
+                    # @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(page_token: :unset, order_by: :unset, type: :unset, limit: nil, page_size: nil)
+                        self.stream(
+                            page_token: page_token,
+                            order_by: order_by,
+                            type: type,
+                            limit: limit,
+                            page_size: page_size
+                        ).entries
+                    end
+
+                    ##
+                    # Streams Instance records from the API as an Enumerable.
+                    # 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] order_by Either 'ASC' or 'DESC' to sort results ascending or descending respectively.
+                    # @param [DataMappingType] type Filter data mappings by type.
+                    # @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 [Enumerable] Enumerable that will yield up to limit results
+                    def stream(page_token: :unset, order_by: :unset, type: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+
+                        page = self.page(
+                            page_token: page_token,
+                            order_by: order_by,
+                            type: type,
+                            page_size: limits[:page_size], )
+
+                        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 DataMappingPageMetadata records from the API as a list.
+                      # @param [String] page_token The token for the page of results to retrieve.
+                      # @param [String] order_by Either 'ASC' or 'DESC' to sort results ascending or descending respectively.
+                      # @param [DataMappingType] type Filter data mappings by type.
+                    # @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(page_token: :unset, order_by: :unset, type: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            'pageToken' => page_token,
+                            'orderBy' => order_by,
+                            'type' => type,
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        DataMappingPageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
+                    ##
+                    # When passed a block, yields DataMappingInstance records from the API.
+                    # This operation lazily loads records as efficiently as possible until the limit
+                    # is reached.
+                    def each
+                        limits = @version.read_limits
+
+                        page = self.page(page_size: limits[:page_size], )
+
+                        return [].each if page.nil?
+
+                        result = @version.stream(page,
+                            limit: limits[:limit],
+                            page_limit: limits[:page_limit])
+                        return [].each if result.nil?
+                        result.each {|x| yield x}
+                    end
+
+                    ##
+                    # Retrieve a single page of DataMappingInstance records from the API.
+                    # Request is executed immediately.
+                    # @param [String] page_token The token for the page of results to retrieve.
+                    # @param [String] order_by Either 'ASC' or 'DESC' to sort results ascending or descending respectively.
+                    # @param [DataMappingType] type Filter data mappings by type.
+                    
+                    # @return [Page] Page of DataMappingInstance
+                    def page(page_token: :unset, order_by: :unset, type: :unset, page_size: :unset)
+                        params = Twilio::Values.of({
+                            'pageToken' => page_token,
+                            'orderBy' => order_by,
+                            'type' => type,
+                                                        'PageSize' => page_size,
+                        })
+                        headers = Twilio::Values.of({})
+                        
+                        
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        DataMappingPage.new(@version, response, @solution)
+                    end
+
+                    ##
+                    # Retrieve a single page of DataMappingInstance records from the API.
+                    # Request is executed immediately.
+                    # @param [String] target_url API-generated URL for the requested results page
+                    # @return [Page] Page of DataMappingInstance
+                    def get_page(target_url)
+                        response = @version.domain.request(
+                            'GET',
+                            target_url
+                        )
+                    DataMappingPage.new(@version, response, @solution)
+                    end
+                    
+
+
+                    # Provide a user friendly representation
+                    def to_s
+                        '#<Twilio.Memory.V1.DataMappingList>'
+                    end
+                end
+
+
+                class DataMappingContext < InstanceContext
+                    ##
+                    # Initialize the DataMappingContext
+                    # @param [Version] version Version that contains the resource
+                    # @param [String] store_id A unique Memory Store ID using Twilio Type ID (TTID) format
+                    # @param [String] data_mapping_id A unique DataMapping ID using Twilio Type ID (TTID) format
+                    # @return [DataMappingContext] DataMappingContext
+                    def initialize(version, store_id, data_mapping_id)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+
+                        # Path Solution
+                        @solution = { store_id: store_id, data_mapping_id: data_mapping_id,  }
+                        @uri = "/ControlPlane/Stores/#{@solution[:store_id]}/DataMappings/#{@solution[:data_mapping_id]}"
+
+                        
+                    end
+                    ##
+                    # Delete the DataMappingInstance
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        response = @version.delete_with_metadata('DELETE', @uri, headers: headers)
+                        DataMappingInstance.new(
+                          @version,
+                          response.body,
+                            store_id: @solution[:store_id],
+                            data_mapping_id: @solution[:data_mapping_id],
+                        )
+                        
+                    end
+
+                    ##
+                    # Delete the DataMappingInstanceMetadata
+                    # @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)
+                          dataMapping_instance = DataMappingInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          DataMappingInstanceMetadata.new(@version, dataMapping_instance, response.headers, response.status_code)
+                    end
+
+                    ##
+                    # Fetch the DataMappingInstance
+                    # @return [DataMappingInstance] Fetched DataMappingInstance
+                    def fetch
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.fetch('GET', @uri, headers: headers)
+                        DataMappingInstance.new(
+                            @version,
+                            payload,
+                            store_id: @solution[:store_id],
+                            data_mapping_id: @solution[:data_mapping_id],
+                        )
+                    end
+
+                    ##
+                    # Fetch the DataMappingInstanceMetadata
+                    # @return [DataMappingInstance] Fetched DataMappingInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        data_mapping_instance = DataMappingInstance.new(
+                            @version,
+                            response.body,
+                            store_id: @solution[:store_id],
+                            data_mapping_id: @solution[:data_mapping_id],
+                        )
+                        DataMappingInstanceMetadata.new(
+                            @version,
+                            data_mapping_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+                    ##
+                    # Patch the DataMappingInstance
+                    # @param [String] if_match Allows for optimistic concurrency control by making the request conditional. Server will only act if the resource's current Entity Tag (ETag) matches the one provided, preventing accidental overwrites.
+                    # @param [DataMappingCore] data_mapping_core 
+                    # @return [DataMappingInstance] Patched DataMappingInstance
+                    def patch(
+                      if_match: :unset,
+                      data_mapping_core: :unset
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', 'If-Match' => if_match, })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        payload = @version.patch('PATCH', @uri, headers: headers, data: data_mapping_core.to_json)
+                        DataMappingInstance.new(
+                            @version,
+                            payload,
+                            store_id: @solution[:store_id],
+                            data_mapping_id: @solution[:data_mapping_id],
+                        )
+                    end
+
+                    ##
+                    # Patch the DataMappingInstanceMetadata
+                    # @param [String] if_match Allows for optimistic concurrency control by making the request conditional. Server will only act if the resource's current Entity Tag (ETag) matches the one provided, preventing accidental overwrites.
+                    # @param [DataMappingCore] data_mapping_core 
+                    # @return [DataMappingInstance] Patchd DataMappingInstance
+                    def patch_with_metadata(
+                      if_match: :unset,
+                    data_mapping_core: :unset
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', 'If-Match' => if_match, })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        response = @version.patch_with_metadata('PATCH', @uri, headers: headers, data: data_mapping_core.to_json)
+                        data_mapping_instance = DataMappingInstance.new(
+                            @version,
+                            response.body,
+                            store_id: @solution[:store_id],
+                            data_mapping_id: @solution[:data_mapping_id],
+                        )
+                        DataMappingInstanceMetadata.new(
+                            @version,
+                            data_mapping_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Memory.V1.DataMappingContext #{context}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Memory.V1.DataMappingContext #{context}>"
+                    end
+                end
+
+                class DataMappingInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new DataMappingInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}DataMappingInstance] data_mapping_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 [DataMappingInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, data_mapping_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @data_mapping_instance = data_mapping_instance
+                    end
+
+                    def data_mapping
+                        @data_mapping_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.DataMappingInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class DataMappingListResponse < InstanceListResource
+                    # @param [Array<DataMappingInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @data_mapping_instance = payload.body[key].map do |data|
+                        DataMappingInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def data_mapping_instance
+                          @instance
+                      end
+                  end
+
+                class DataMappingPage < TokenPage
+                    ##
+                    # Initialize the DataMappingPage
+                    # @param [Version] version Version that contains the resource
+                    # @param [Response] response Response from the API
+                    # @param [Hash] solution Path solution for the resource
+                    # @return [DataMappingPage] DataMappingPage
+                    def initialize(version, response, solution)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version, response)
+
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    ##
+                    # Build an instance of DataMappingInstance
+                    # @param [Hash] payload Payload response from the API
+                    # @return [DataMappingInstance] DataMappingInstance
+                    def get_instance(payload)
+                        DataMappingInstance.new(@version, payload, store_id: @solution[:store_id])
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        '<Twilio.Memory.V1.DataMappingPage>'
+                    end
+                end
+
+                class DataMappingPageMetadata < PageMetadata
+                    attr_reader :data_mapping_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @data_mapping_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @data_mapping_page << DataMappingListResponse.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
+                        @data_mapping_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Memory::V1PageMetadata>';
+                    end
+                end
+                class DataMappingListResponse < InstanceListResource
+
+                    # @param [Array<DataMappingInstance>] 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
+                      @data_mapping = data_list.map do |data|
+                        DataMappingInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def data_mapping
+                        @data_mapping
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
+                class DataMappingInstance < InstanceResource
+                    ##
+                    # Initialize the DataMappingInstance
+                    # @param [Version] version Version that contains the resource
+                    # @param [Hash] payload payload that contains response from Twilio
+                    # @param [String] account_sid The SID of the
+                    #   {Account}[https://www.twilio.com/docs/iam/api/account] that created this DataMapping
+                    #   resource.
+                    # @param [String] sid The SID of the Call resource to fetch.
+                    # @return [DataMappingInstance] DataMappingInstance
+                    def initialize(version, payload , store_id: nil, data_mapping_id: nil)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+                        
+                        # Marshaled Properties
+                        @properties = { 
+                            'message' => payload['message'],
+                            'status_url' => payload['status_url'],
+                            'display_name' => payload['display_name'],
+                            'description' => payload['description'],
+                            'is_enabled' => payload['is_enabled'],
+                            'mapping_to' => payload['mapping_to'],
+                            'mapping_from' => payload['mapping_from'],
+                            'id' => payload['id'],
+                            'created_at' => Twilio.deserialize_iso8601_datetime(payload['created_at']),
+                            'updated_at' => Twilio.deserialize_iso8601_datetime(payload['updated_at']),
+                            'version' => payload['version'] == nil ? payload['version'] : payload['version'].to_i,
+                        }
+
+                        # Context
+                        @instance_context = nil
+                        @params = { 'store_id' => store_id  || @properties['store_id']  ,'data_mapping_id' => data_mapping_id  || @properties['data_mapping_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 [DataMappingContext] CallContext for this CallInstance
+                    def context
+                        unless @instance_context
+                            @instance_context = DataMappingContext.new(@version , @params['store_id'], @params['data_mapping_id'])
+                        end
+                        @instance_context
+                    end
+                    
+                    ##
+                    # @return [String] 
+                    def message
+                        @properties['message']
+                    end
+                    
+                    ##
+                    # @return [String] URI to check operation status.
+                    def status_url
+                        @properties['status_url']
+                    end
+                    
+                    ##
+                    # @return [String] Name of the data mapping.
+                    def display_name
+                        @properties['display_name']
+                    end
+                    
+                    ##
+                    # @return [String] A human readable description of this resource, up to 512 characters.
+                    def description
+                        @properties['description']
+                    end
+                    
+                    ##
+                    # @return [Boolean] Flag indicating whether the data mapping is active. When true, data will be ingested and mapped according to the configuration. When false, the data mapping will be inactive and no data will be ingested into the Memory Store.
+                    def is_enabled
+                        @properties['is_enabled']
+                    end
+                    
+                    ##
+                    # @return [DataMappingToTraits] 
+                    def mapping_to
+                        @properties['mapping_to']
+                    end
+                    
+                    ##
+                    # @return [DataMappingFromDataSet] 
+                    def mapping_from
+                        @properties['mapping_from']
+                    end
+                    
+                    ##
+                    # @return [String] The unique identifier for the data mapping.
+                    def id
+                        @properties['id']
+                    end
+                    
+                    ##
+                    # @return [Time] The ISO 8601 timestamp when the  data mapping was created.
+                    def created_at
+                        @properties['created_at']
+                    end
+                    
+                    ##
+                    # @return [Time] The ISO 8601 timestamp when the data mapping was last updated.
+                    def updated_at
+                        @properties['updated_at']
+                    end
+                    
+                    ##
+                    # @return [String] The current version number of the DataMapping. Incremented on each successful update.
+                    def version
+                        @properties['version']
+                    end
+                    
+                    ##
+                    # Delete the DataMappingInstance
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete
+
+                        context.delete
+                    end
+
+                    ##
+                    # Fetch the DataMappingInstance
+                    # @return [DataMappingInstance] Fetched DataMappingInstance
+                    def fetch
+
+                        context.fetch
+                    end
+
+                    ##
+                    # Patch the DataMappingInstance
+                    # @param [String] if_match Allows for optimistic concurrency control by making the request conditional. Server will only act if the resource's current Entity Tag (ETag) matches the one provided, preventing accidental overwrites.
+                    # @param [DataMappingCore] data_mapping_core 
+                    # @return [DataMappingInstance] Patched DataMappingInstance
+                    def patch(
+                      if_match: :unset,
+                      data_mapping_core: :unset
+                    )
+
+                        context.patch(
+                            if_match: if_match, 
+                            data_mapping_core: data_mapping_core, 
+                        )
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Memory.V1.DataMappingInstance #{values}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Memory.V1.DataMappingInstance #{values}>"
+                    end
+                end
+
+            end
+        end
+    end
+end