twilio-ruby 7.10.5 → 7.10.6

data/lib/twilio-ruby/rest/knowledge/v2/knowledge_basis.rb

@@ -0,0 +1,739 @@
+##
+#    This code was generated by
+#    ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+#     |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+#     |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+#
+#    Twilio Knowledge API
+#    APIs for managing knowledge bases and knowledge content for AI-powered applications.
+#
+#    NOTE: This class is auto generated by OpenAPI Generator.
+#    https://openapi-generator.tech
+#    Do not edit the class manually.
+#
+
+
+module Twilio
+    module REST
+        class Knowledge < KnowledgeBase
+            class V2 < Version
+                class KnowledgeBasisList < ListResource
+                
+                    class KnowledgeBaseCore
+                            # @param [display_name]: [String] Provides a unique and addressable name to be assigned to this Knowledge Base. This name is assigned by the developer and can be used in addition to the ID. It is intended to be human-readable and unique within the account.
+                            # @param [description]: [String] A human readable description of this resource, up to 128 characters.
+                        attr_accessor :display_name, :description
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class UpdateKnowledgeBaseRequest
+                            # @param [display_name]: [String] Provides a unique and addressable name to be assigned to this Knowledge Base. This name is assigned by the developer and can be used in addition to the ID. It is intended to be human-readable and unique within the account.
+                            # @param [description]: [String] A human readable description of this resource, up to 128 characters.
+                        attr_accessor :display_name, :description
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                        }.to_json(options)
+                        end
+                    end
+
+
+                    class KnowledgeBaseCore
+                            # @param [display_name]: [String] Provides a unique and addressable name to be assigned to this Knowledge Base. This name is assigned by the developer and can be used in addition to the ID. It is intended to be human-readable and unique within the account.
+                            # @param [description]: [String] A human readable description of this resource, up to 128 characters.
+                        attr_accessor :display_name, :description
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class UpdateKnowledgeBaseRequest
+                            # @param [display_name]: [String] Provides a unique and addressable name to be assigned to this Knowledge Base. This name is assigned by the developer and can be used in addition to the ID. It is intended to be human-readable and unique within the account.
+                            # @param [description]: [String] A human readable description of this resource, up to 128 characters.
+                        attr_accessor :display_name, :description
+                        def initialize(payload)
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "displayName": @display_name,
+                                "description": @description,
+                        }.to_json(options)
+                        end
+                    end
+
+
+                    ##
+                    # Initialize the KnowledgeBasisList
+                    # @param [Version] version Version that contains the resource
+                    # @return [KnowledgeBasisList] KnowledgeBasisList
+                    def initialize(version)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+                        # Path Solution
+                        @solution = {  }
+                        @uri = "/ControlPlane/KnowledgeBases"
+                        
+                    end
+                    ##
+                    # Create the KnowledgeBasisInstance
+                    # @param [KnowledgeBaseCore] knowledge_base_core 
+                    # @return [KnowledgeBasisInstance] Created KnowledgeBasisInstance
+                    def create(knowledge_base_core: 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: knowledge_base_core.to_json)
+                        KnowledgeBasisInstance.new(
+                            @version,
+                            payload,
+                        )
+                    end
+
+                    ##
+                    # Create the KnowledgeBasisInstanceMetadata
+                    # @param [KnowledgeBaseCore] knowledge_base_core 
+                    # @return [KnowledgeBasisInstance] Created KnowledgeBasisInstance
+                    def create_with_metadata(knowledge_base_core: 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: knowledge_base_core.to_json)
+                        knowledge_basis_instance = KnowledgeBasisInstance.new(
+                            @version,
+                            response.body,
+                        )
+                        KnowledgeBasisInstanceMetadata.new(
+                            @version,
+                            knowledge_basis_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+                
+                    ##
+                    # Lists KnowledgeBasisInstance 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 [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, limit: nil, page_size: nil)
+                        self.stream(
+                            page_token: page_token,
+                            order_by: order_by,
+                            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 [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, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+
+                        page = self.page(
+                            page_token: page_token,
+                            order_by: order_by,
+                            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 KnowledgeBasisPageMetadata 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 [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, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            'pageToken' => page_token,
+                            'orderBy' => order_by,
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        KnowledgeBasisPageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
+                    ##
+                    # When passed a block, yields KnowledgeBasisInstance 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 KnowledgeBasisInstance 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.
+                    
+                    # @return [Page] Page of KnowledgeBasisInstance
+                    def page(page_token: :unset, order_by: :unset, page_size: :unset)
+                        params = Twilio::Values.of({
+                            'pageToken' => page_token,
+                            'orderBy' => order_by,
+                                                        'PageSize' => page_size,
+                        })
+                        headers = Twilio::Values.of({})
+                        
+                        
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        KnowledgeBasisPage.new(@version, response, @solution)
+                    end
+
+                    ##
+                    # Retrieve a single page of KnowledgeBasisInstance records from the API.
+                    # Request is executed immediately.
+                    # @param [String] target_url API-generated URL for the requested results page
+                    # @return [Page] Page of KnowledgeBasisInstance
+                    def get_page(target_url)
+                        response = @version.domain.request(
+                            'GET',
+                            target_url
+                        )
+                    KnowledgeBasisPage.new(@version, response, @solution)
+                    end
+                    
+
+
+                    # Provide a user friendly representation
+                    def to_s
+                        '#<Twilio.Knowledge.V2.KnowledgeBasisList>'
+                    end
+                end
+
+
+                class KnowledgeBasisContext < InstanceContext
+                    ##
+                    # Initialize the KnowledgeBasisContext
+                    # @param [Version] version Version that contains the resource
+                    # @param [String] kb_id A unique Knowledge Base ID using Twilio Type ID (TTID) format
+                    # @return [KnowledgeBasisContext] KnowledgeBasisContext
+                    def initialize(version, kb_id)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+
+                        # Path Solution
+                        @solution = { kb_id: kb_id,  }
+                        @uri = "/ControlPlane/KnowledgeBases/#{@solution[:kb_id]}"
+
+                        
+                    end
+                    ##
+                    # Delete the KnowledgeBasisInstance
+                    # @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)
+                        KnowledgeBasisInstance.new(
+                          @version,
+                          response.body,
+                            kb_id: @solution[:kb_id],
+                        )
+                        
+                    end
+
+                    ##
+                    # Delete the KnowledgeBasisInstanceMetadata
+                    # @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)
+                          knowledgeBasis_instance = KnowledgeBasisInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          KnowledgeBasisInstanceMetadata.new(@version, knowledgeBasis_instance, response.headers, response.status_code)
+                    end
+
+                    ##
+                    # Fetch the KnowledgeBasisInstance
+                    # @return [KnowledgeBasisInstance] Fetched KnowledgeBasisInstance
+                    def fetch
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.fetch('GET', @uri, headers: headers)
+                        KnowledgeBasisInstance.new(
+                            @version,
+                            payload,
+                            kb_id: @solution[:kb_id],
+                        )
+                    end
+
+                    ##
+                    # Fetch the KnowledgeBasisInstanceMetadata
+                    # @return [KnowledgeBasisInstance] Fetched KnowledgeBasisInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        knowledge_basis_instance = KnowledgeBasisInstance.new(
+                            @version,
+                            response.body,
+                            kb_id: @solution[:kb_id],
+                        )
+                        KnowledgeBasisInstanceMetadata.new(
+                            @version,
+                            knowledge_basis_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+                    ##
+                    # Update the KnowledgeBasisInstance
+                    # @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 [UpdateKnowledgeBaseRequest] update_knowledge_base_request 
+                    # @return [KnowledgeBasisInstance] Updated KnowledgeBasisInstance
+                    def update(
+                      if_match: :unset,
+                      update_knowledge_base_request: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', 'If-Match' => if_match, })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        payload = @version.update('PATCH', @uri, headers: headers, data: update_knowledge_base_request.to_json)
+                        KnowledgeBasisInstance.new(
+                            @version,
+                            payload,
+                            kb_id: @solution[:kb_id],
+                        )
+                    end
+
+                    ##
+                    # Update the KnowledgeBasisInstanceMetadata
+                    # @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 [UpdateKnowledgeBaseRequest] update_knowledge_base_request 
+                    # @return [KnowledgeBasisInstance] Updated KnowledgeBasisInstance
+                    def update_with_metadata(
+                      if_match: :unset,
+                    update_knowledge_base_request: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', 'If-Match' => if_match, })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('PATCH', @uri, headers: headers, data: update_knowledge_base_request.to_json)
+                        knowledge_basis_instance = KnowledgeBasisInstance.new(
+                            @version,
+                            response.body,
+                            kb_id: @solution[:kb_id],
+                        )
+                        KnowledgeBasisInstanceMetadata.new(
+                            @version,
+                            knowledge_basis_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Knowledge.V2.KnowledgeBasisContext #{context}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Knowledge.V2.KnowledgeBasisContext #{context}>"
+                    end
+                end
+
+                class KnowledgeBasisInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new KnowledgeBasisInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}KnowledgeBasisInstance] knowledge_basis_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 [KnowledgeBasisInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, knowledge_basis_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @knowledge_basis_instance = knowledge_basis_instance
+                    end
+
+                    def knowledge_basis
+                        @knowledge_basis_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.KnowledgeBasisInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class KnowledgeBasisListResponse < InstanceListResource
+                    # @param [Array<KnowledgeBasisInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @knowledge_basis_instance = payload.body[key].map do |data|
+                        KnowledgeBasisInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def knowledge_basis_instance
+                          @instance
+                      end
+                  end
+
+                class KnowledgeBasisPage < TokenPage
+                    ##
+                    # Initialize the KnowledgeBasisPage
+                    # @param [Version] version Version that contains the resource
+                    # @param [Response] response Response from the API
+                    # @param [Hash] solution Path solution for the resource
+                    # @return [KnowledgeBasisPage] KnowledgeBasisPage
+                    def initialize(version, response, solution)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version, response)
+
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    ##
+                    # Build an instance of KnowledgeBasisInstance
+                    # @param [Hash] payload Payload response from the API
+                    # @return [KnowledgeBasisInstance] KnowledgeBasisInstance
+                    def get_instance(payload)
+                        KnowledgeBasisInstance.new(@version, payload)
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        '<Twilio.Knowledge.V2.KnowledgeBasisPage>'
+                    end
+                end
+
+                class KnowledgeBasisPageMetadata < PageMetadata
+                    attr_reader :knowledge_basis_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @knowledge_basis_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @knowledge_basis_page << KnowledgeBasisListResponse.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
+                        @knowledge_basis_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Knowledge::V2PageMetadata>';
+                    end
+                end
+                class KnowledgeBasisListResponse < InstanceListResource
+
+                    # @param [Array<KnowledgeBasisInstance>] 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
+                      @knowledge_basis = data_list.map do |data|
+                        KnowledgeBasisInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def knowledge_basis
+                        @knowledge_basis
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
+                class KnowledgeBasisInstance < InstanceResource
+                    ##
+                    # Initialize the KnowledgeBasisInstance
+                    # @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 KnowledgeBasis
+                    #   resource.
+                    # @param [String] sid The SID of the Call resource to fetch.
+                    # @return [KnowledgeBasisInstance] KnowledgeBasisInstance
+                    def initialize(version, payload , kb_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'],
+                            'id' => payload['id'],
+                            'status' => payload['status'],
+                            '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 = { 'kb_id' => kb_id  || @properties['kb_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 [KnowledgeBasisContext] CallContext for this CallInstance
+                    def context
+                        unless @instance_context
+                            @instance_context = KnowledgeBasisContext.new(@version , @params['kb_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] Provides a unique and addressable name to be assigned to this Knowledge Base. This name is assigned by the developer and can be used in addition to the ID. It is intended to be human-readable and unique within the account.
+                    def display_name
+                        @properties['display_name']
+                    end
+                    
+                    ##
+                    # @return [String] A human readable description of this resource, up to 128 characters.
+                    def description
+                        @properties['description']
+                    end
+                    
+                    ##
+                    # @return [String] The unique identifier for the Knowledge Base
+                    def id
+                        @properties['id']
+                    end
+                    
+                    ##
+                    # @return [String] The provisioning status of the Knowledge Base
+                    def status
+                        @properties['status']
+                    end
+                    
+                    ##
+                    # @return [Time] The ISO 8601 timestamp when the Knowledge Base was created.
+                    def created_at
+                        @properties['created_at']
+                    end
+                    
+                    ##
+                    # @return [Time] The ISO 8601 timestamp when the Knowledge Base was last updated.
+                    def updated_at
+                        @properties['updated_at']
+                    end
+                    
+                    ##
+                    # @return [String] The current version number of the Knowledge Base. Incremented on each successful mutable update.
+                    def version
+                        @properties['version']
+                    end
+                    
+                    ##
+                    # Delete the KnowledgeBasisInstance
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete
+
+                        context.delete
+                    end
+
+                    ##
+                    # Fetch the KnowledgeBasisInstance
+                    # @return [KnowledgeBasisInstance] Fetched KnowledgeBasisInstance
+                    def fetch
+
+                        context.fetch
+                    end
+
+                    ##
+                    # Update the KnowledgeBasisInstance
+                    # @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 [UpdateKnowledgeBaseRequest] update_knowledge_base_request 
+                    # @return [KnowledgeBasisInstance] Updated KnowledgeBasisInstance
+                    def update(
+                      if_match: :unset,
+                      update_knowledge_base_request: nil
+                    )
+
+                        context.update(
+                            if_match: if_match, 
+                            update_knowledge_base_request: update_knowledge_base_request, 
+                        )
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Knowledge.V2.KnowledgeBasisInstance #{values}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Knowledge.V2.KnowledgeBasisInstance #{values}>"
+                    end
+                end
+
+            end
+        end
+    end
+end