Documentation

Overview

    Package qnamaker implements the Azure ARM Qnamaker service API version 4.0.

    An API for QnAMaker Service

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func UserAgent

    func UserAgent() string

      UserAgent returns the UserAgent string to use when sending http.Requests.

      func Version

      func Version() string

        Version returns the semantic version (see http://semver.org) of the client.

        Types

        type ActiveLearningSettingsDTO

        type ActiveLearningSettingsDTO struct {
        	// Enable - True/False string providing Active Learning
        	Enable *string `json:"enable,omitempty"`
        }

          ActiveLearningSettingsDTO active Learning settings of the endpoint.

          type AlterationsClient

          type AlterationsClient struct {
          	BaseClient
          }

            AlterationsClient is the an API for QnAMaker Service

            func NewAlterationsClient

            func NewAlterationsClient(endpoint string) AlterationsClient

              NewAlterationsClient creates an instance of the AlterationsClient client.

              func (AlterationsClient) Get

              func (client AlterationsClient) Get(ctx context.Context) (result WordAlterationsDTO, err error)

                Get sends the get request.

                func (AlterationsClient) GetPreparer

                func (client AlterationsClient) GetPreparer(ctx context.Context) (*http.Request, error)

                  GetPreparer prepares the Get request.

                  func (AlterationsClient) GetResponder

                  func (client AlterationsClient) GetResponder(resp *http.Response) (result WordAlterationsDTO, err error)

                    GetResponder handles the response to the Get request. The method always closes the http.Response Body.

                    func (AlterationsClient) GetSender

                    func (client AlterationsClient) GetSender(req *http.Request) (*http.Response, error)

                      GetSender sends the Get request. The method will close the http.Response Body if it receives an error.

                      func (AlterationsClient) Replace

                      func (client AlterationsClient) Replace(ctx context.Context, wordAlterations WordAlterationsDTO) (result autorest.Response, err error)

                        Replace sends the replace request. Parameters: wordAlterations - new alterations data.

                        func (AlterationsClient) ReplacePreparer

                        func (client AlterationsClient) ReplacePreparer(ctx context.Context, wordAlterations WordAlterationsDTO) (*http.Request, error)

                          ReplacePreparer prepares the Replace request.

                          func (AlterationsClient) ReplaceResponder

                          func (client AlterationsClient) ReplaceResponder(resp *http.Response) (result autorest.Response, err error)

                            ReplaceResponder handles the response to the Replace request. The method always closes the http.Response Body.

                            func (AlterationsClient) ReplaceSender

                            func (client AlterationsClient) ReplaceSender(req *http.Request) (*http.Response, error)

                              ReplaceSender sends the Replace request. The method will close the http.Response Body if it receives an error.

                              type AlterationsDTO

                              type AlterationsDTO struct {
                              	// Alterations - Words that are synonymous with each other.
                              	Alterations *[]string `json:"alterations,omitempty"`
                              }

                                AlterationsDTO collection of words that are synonyms.

                                type BaseClient

                                type BaseClient struct {
                                	autorest.Client
                                	Endpoint string
                                }

                                  BaseClient is the base client for Qnamaker.

                                  func New

                                  func New(endpoint string) BaseClient

                                    New creates an instance of the BaseClient client.

                                    func NewWithoutDefaults

                                    func NewWithoutDefaults(endpoint string) BaseClient

                                      NewWithoutDefaults creates an instance of the BaseClient client.

                                      type ContextDTO

                                      type ContextDTO struct {
                                      	// IsContextOnly - To mark if a prompt is relevant only with a previous question or not.
                                      	// true - Do not include this QnA as search result for queries without context
                                      	// false - ignores context and includes this QnA in search result
                                      	IsContextOnly *bool `json:"isContextOnly,omitempty"`
                                      	// Prompts - List of prompts associated with the answer.
                                      	Prompts *[]PromptDTO `json:"prompts,omitempty"`
                                      }

                                        ContextDTO context associated with Qna.

                                        type CreateKbDTO

                                        type CreateKbDTO struct {
                                        	// Name - Friendly name for the knowledgebase.
                                        	Name *string `json:"name,omitempty"`
                                        	// QnaList - List of Q-A (QnADTO) to be added to the knowledgebase. Q-A Ids are assigned by the service and should be omitted.
                                        	QnaList *[]QnADTO `json:"qnaList,omitempty"`
                                        	// Urls - List of URLs to be used for extracting Q-A.
                                        	Urls *[]string `json:"urls,omitempty"`
                                        	// Files - List of files from which to Extract Q-A.
                                        	Files *[]FileDTO `json:"files,omitempty"`
                                        	// EnableHierarchicalExtraction - Enable hierarchical extraction of Q-A from files and urls. Value to be considered False if this field is not present.
                                        	EnableHierarchicalExtraction *bool `json:"enableHierarchicalExtraction,omitempty"`
                                        	// DefaultAnswerUsedForExtraction - Text string to be used as the answer in any Q-A which has no extracted answer from the document but has a hierarchy. Required when EnableHierarchicalExtraction field is set to True.
                                        	DefaultAnswerUsedForExtraction *string `json:"defaultAnswerUsedForExtraction,omitempty"`
                                        	// Language - Language of the knowledgebase. Please find the list of supported languages <a href="https://aka.ms/qnamaker-languages#languages-supported" target="_blank">here</a>.
                                        	Language *string `json:"language,omitempty"`
                                        }

                                          CreateKbDTO post body schema for CreateKb operation.

                                          type CreateKbInputDTO

                                          type CreateKbInputDTO struct {
                                          	// QnaList - List of QNA to be added to the index. Ids are generated by the service and should be omitted.
                                          	QnaList *[]QnADTO `json:"qnaList,omitempty"`
                                          	// Urls - List of URLs to be added to knowledgebase.
                                          	Urls *[]string `json:"urls,omitempty"`
                                          	// Files - List of files to be added to knowledgebase.
                                          	Files *[]FileDTO `json:"files,omitempty"`
                                          }

                                            CreateKbInputDTO input to create KB.

                                            type DeleteKbContentsDTO

                                            type DeleteKbContentsDTO struct {
                                            	// Ids - List of Qna Ids to be deleted
                                            	Ids *[]int32 `json:"ids,omitempty"`
                                            	// Sources - List of sources to be deleted from knowledgebase.
                                            	Sources *[]string `json:"sources,omitempty"`
                                            }

                                              DeleteKbContentsDTO PATCH body schema of Delete Operation in UpdateKb

                                              type EndpointKeysClient

                                              type EndpointKeysClient struct {
                                              	BaseClient
                                              }

                                                EndpointKeysClient is the an API for QnAMaker Service

                                                func NewEndpointKeysClient

                                                func NewEndpointKeysClient(endpoint string) EndpointKeysClient

                                                  NewEndpointKeysClient creates an instance of the EndpointKeysClient client.

                                                  func (EndpointKeysClient) GetKeys

                                                  func (client EndpointKeysClient) GetKeys(ctx context.Context) (result EndpointKeysDTO, err error)

                                                    GetKeys sends the get keys request.

                                                    func (EndpointKeysClient) GetKeysPreparer

                                                    func (client EndpointKeysClient) GetKeysPreparer(ctx context.Context) (*http.Request, error)

                                                      GetKeysPreparer prepares the GetKeys request.

                                                      func (EndpointKeysClient) GetKeysResponder

                                                      func (client EndpointKeysClient) GetKeysResponder(resp *http.Response) (result EndpointKeysDTO, err error)

                                                        GetKeysResponder handles the response to the GetKeys request. The method always closes the http.Response Body.

                                                        func (EndpointKeysClient) GetKeysSender

                                                        func (client EndpointKeysClient) GetKeysSender(req *http.Request) (*http.Response, error)

                                                          GetKeysSender sends the GetKeys request. The method will close the http.Response Body if it receives an error.

                                                          func (EndpointKeysClient) RefreshKeys

                                                          func (client EndpointKeysClient) RefreshKeys(ctx context.Context, keyType string) (result EndpointKeysDTO, err error)

                                                            RefreshKeys sends the refresh keys request. Parameters: keyType - type of Key

                                                            func (EndpointKeysClient) RefreshKeysPreparer

                                                            func (client EndpointKeysClient) RefreshKeysPreparer(ctx context.Context, keyType string) (*http.Request, error)

                                                              RefreshKeysPreparer prepares the RefreshKeys request.

                                                              func (EndpointKeysClient) RefreshKeysResponder

                                                              func (client EndpointKeysClient) RefreshKeysResponder(resp *http.Response) (result EndpointKeysDTO, err error)

                                                                RefreshKeysResponder handles the response to the RefreshKeys request. The method always closes the http.Response Body.

                                                                func (EndpointKeysClient) RefreshKeysSender

                                                                func (client EndpointKeysClient) RefreshKeysSender(req *http.Request) (*http.Response, error)

                                                                  RefreshKeysSender sends the RefreshKeys request. The method will close the http.Response Body if it receives an error.

                                                                  type EndpointKeysDTO

                                                                  type EndpointKeysDTO struct {
                                                                  	autorest.Response `json:"-"`
                                                                  	// PrimaryEndpointKey - Primary Access Key.
                                                                  	PrimaryEndpointKey *string `json:"primaryEndpointKey,omitempty"`
                                                                  	// SecondaryEndpointKey - Secondary Access Key.
                                                                  	SecondaryEndpointKey *string `json:"secondaryEndpointKey,omitempty"`
                                                                  	// InstalledVersion - Current version of runtime.
                                                                  	InstalledVersion *string `json:"installedVersion,omitempty"`
                                                                  	// LastStableVersion - Latest version of runtime.
                                                                  	LastStableVersion *string `json:"lastStableVersion,omitempty"`
                                                                  	// Language - Language setting of runtime.
                                                                  	Language *string `json:"language,omitempty"`
                                                                  }

                                                                    EndpointKeysDTO schema for EndpointKeys generate/refresh operations.

                                                                    type EndpointSettingsClient

                                                                    type EndpointSettingsClient struct {
                                                                    	BaseClient
                                                                    }

                                                                      EndpointSettingsClient is the an API for QnAMaker Service

                                                                      func NewEndpointSettingsClient

                                                                      func NewEndpointSettingsClient(endpoint string) EndpointSettingsClient

                                                                        NewEndpointSettingsClient creates an instance of the EndpointSettingsClient client.

                                                                        func (EndpointSettingsClient) GetSettings

                                                                        func (client EndpointSettingsClient) GetSettings(ctx context.Context) (result EndpointSettingsDTO, err error)

                                                                          GetSettings sends the get settings request.

                                                                          func (EndpointSettingsClient) GetSettingsPreparer

                                                                          func (client EndpointSettingsClient) GetSettingsPreparer(ctx context.Context) (*http.Request, error)

                                                                            GetSettingsPreparer prepares the GetSettings request.

                                                                            func (EndpointSettingsClient) GetSettingsResponder

                                                                            func (client EndpointSettingsClient) GetSettingsResponder(resp *http.Response) (result EndpointSettingsDTO, err error)

                                                                              GetSettingsResponder handles the response to the GetSettings request. The method always closes the http.Response Body.

                                                                              func (EndpointSettingsClient) GetSettingsSender

                                                                              func (client EndpointSettingsClient) GetSettingsSender(req *http.Request) (*http.Response, error)

                                                                                GetSettingsSender sends the GetSettings request. The method will close the http.Response Body if it receives an error.

                                                                                func (EndpointSettingsClient) UpdateSettings

                                                                                func (client EndpointSettingsClient) UpdateSettings(ctx context.Context, endpointSettingsPayload EndpointSettingsDTO) (result autorest.Response, err error)

                                                                                  UpdateSettings sends the update settings request. Parameters: endpointSettingsPayload - post body of the request.

                                                                                  func (EndpointSettingsClient) UpdateSettingsPreparer

                                                                                  func (client EndpointSettingsClient) UpdateSettingsPreparer(ctx context.Context, endpointSettingsPayload EndpointSettingsDTO) (*http.Request, error)

                                                                                    UpdateSettingsPreparer prepares the UpdateSettings request.

                                                                                    func (EndpointSettingsClient) UpdateSettingsResponder

                                                                                    func (client EndpointSettingsClient) UpdateSettingsResponder(resp *http.Response) (result autorest.Response, err error)

                                                                                      UpdateSettingsResponder handles the response to the UpdateSettings request. The method always closes the http.Response Body.

                                                                                      func (EndpointSettingsClient) UpdateSettingsSender

                                                                                      func (client EndpointSettingsClient) UpdateSettingsSender(req *http.Request) (*http.Response, error)

                                                                                        UpdateSettingsSender sends the UpdateSettings request. The method will close the http.Response Body if it receives an error.

                                                                                        type EndpointSettingsDTO

                                                                                        type EndpointSettingsDTO struct {
                                                                                        	autorest.Response `json:"-"`
                                                                                        	// ActiveLearning - Active Learning settings of the endpoint.
                                                                                        	ActiveLearning *EndpointSettingsDTOActiveLearning `json:"activeLearning,omitempty"`
                                                                                        }

                                                                                          EndpointSettingsDTO endpoint settings.

                                                                                          type EndpointSettingsDTOActiveLearning

                                                                                          type EndpointSettingsDTOActiveLearning struct {
                                                                                          	// Enable - True/False string providing Active Learning
                                                                                          	Enable *string `json:"enable,omitempty"`
                                                                                          }

                                                                                            EndpointSettingsDTOActiveLearning active Learning settings of the endpoint.

                                                                                            type EnvironmentType

                                                                                            type EnvironmentType string

                                                                                              EnvironmentType enumerates the values for environment type.

                                                                                              const (
                                                                                              	// Prod ...
                                                                                              	Prod EnvironmentType = "Prod"
                                                                                              	// Test ...
                                                                                              	Test EnvironmentType = "Test"
                                                                                              )

                                                                                              func PossibleEnvironmentTypeValues

                                                                                              func PossibleEnvironmentTypeValues() []EnvironmentType

                                                                                                PossibleEnvironmentTypeValues returns an array of possible values for the EnvironmentType const type.

                                                                                                type Error

                                                                                                type Error struct {
                                                                                                	// Code - One of a server-defined set of error codes. Possible values include: 'BadArgument', 'Forbidden', 'NotFound', 'KbNotFound', 'Unauthorized', 'Unspecified', 'EndpointKeysError', 'QuotaExceeded', 'QnaRuntimeError', 'SKULimitExceeded', 'OperationNotFound', 'ServiceError', 'ValidationFailure', 'ExtractionFailure'
                                                                                                	Code ErrorCodeType `json:"code,omitempty"`
                                                                                                	// Message - A human-readable representation of the error.
                                                                                                	Message *string `json:"message,omitempty"`
                                                                                                	// Target - The target of the error.
                                                                                                	Target *string `json:"target,omitempty"`
                                                                                                	// Details - An array of details about specific errors that led to this reported error.
                                                                                                	Details *[]Error `json:"details,omitempty"`
                                                                                                	// InnerError - An object containing more specific information than the current object about the error.
                                                                                                	InnerError *InnerErrorModel `json:"innerError,omitempty"`
                                                                                                }

                                                                                                  Error the error object. As per Microsoft One API guidelines - https://github.com/Microsoft/api-guidelines/blob/vNext/Guidelines.md#7102-error-condition-responses.

                                                                                                  type ErrorCodeType

                                                                                                  type ErrorCodeType string

                                                                                                    ErrorCodeType enumerates the values for error code type.

                                                                                                    const (
                                                                                                    	// BadArgument ...
                                                                                                    	BadArgument ErrorCodeType = "BadArgument"
                                                                                                    	// EndpointKeysError ...
                                                                                                    	EndpointKeysError ErrorCodeType = "EndpointKeysError"
                                                                                                    	// ExtractionFailure ...
                                                                                                    	ExtractionFailure ErrorCodeType = "ExtractionFailure"
                                                                                                    	// Forbidden ...
                                                                                                    	Forbidden ErrorCodeType = "Forbidden"
                                                                                                    	// KbNotFound ...
                                                                                                    	KbNotFound ErrorCodeType = "KbNotFound"
                                                                                                    	// NotFound ...
                                                                                                    	NotFound ErrorCodeType = "NotFound"
                                                                                                    	// OperationNotFound ...
                                                                                                    	OperationNotFound ErrorCodeType = "OperationNotFound"
                                                                                                    	// QnaRuntimeError ...
                                                                                                    	QnaRuntimeError ErrorCodeType = "QnaRuntimeError"
                                                                                                    	// QuotaExceeded ...
                                                                                                    	QuotaExceeded ErrorCodeType = "QuotaExceeded"
                                                                                                    	// ServiceError ...
                                                                                                    	ServiceError ErrorCodeType = "ServiceError"
                                                                                                    	// SKULimitExceeded ...
                                                                                                    	SKULimitExceeded ErrorCodeType = "SKULimitExceeded"
                                                                                                    	// Unauthorized ...
                                                                                                    	Unauthorized ErrorCodeType = "Unauthorized"
                                                                                                    	// Unspecified ...
                                                                                                    	Unspecified ErrorCodeType = "Unspecified"
                                                                                                    	// ValidationFailure ...
                                                                                                    	ValidationFailure ErrorCodeType = "ValidationFailure"
                                                                                                    )

                                                                                                    func PossibleErrorCodeTypeValues

                                                                                                    func PossibleErrorCodeTypeValues() []ErrorCodeType

                                                                                                      PossibleErrorCodeTypeValues returns an array of possible values for the ErrorCodeType const type.

                                                                                                      type ErrorResponse

                                                                                                      type ErrorResponse struct {
                                                                                                      	// Error - The error object.
                                                                                                      	Error *ErrorResponseError `json:"error,omitempty"`
                                                                                                      }

                                                                                                        ErrorResponse error response. As per Microsoft One API guidelines - https://github.com/Microsoft/api-guidelines/blob/vNext/Guidelines.md#7102-error-condition-responses.

                                                                                                        type ErrorResponseError

                                                                                                        type ErrorResponseError struct {
                                                                                                        	// Code - One of a server-defined set of error codes. Possible values include: 'BadArgument', 'Forbidden', 'NotFound', 'KbNotFound', 'Unauthorized', 'Unspecified', 'EndpointKeysError', 'QuotaExceeded', 'QnaRuntimeError', 'SKULimitExceeded', 'OperationNotFound', 'ServiceError', 'ValidationFailure', 'ExtractionFailure'
                                                                                                        	Code ErrorCodeType `json:"code,omitempty"`
                                                                                                        	// Message - A human-readable representation of the error.
                                                                                                        	Message *string `json:"message,omitempty"`
                                                                                                        	// Target - The target of the error.
                                                                                                        	Target *string `json:"target,omitempty"`
                                                                                                        	// Details - An array of details about specific errors that led to this reported error.
                                                                                                        	Details *[]Error `json:"details,omitempty"`
                                                                                                        	// InnerError - An object containing more specific information than the current object about the error.
                                                                                                        	InnerError *InnerErrorModel `json:"innerError,omitempty"`
                                                                                                        }

                                                                                                          ErrorResponseError the error object.

                                                                                                          type FileDTO

                                                                                                          type FileDTO struct {
                                                                                                          	// FileName - File name. Supported file types are ".tsv", ".pdf", ".txt", ".docx", ".xlsx".
                                                                                                          	FileName *string `json:"fileName,omitempty"`
                                                                                                          	// FileURI - Public URI of the file.
                                                                                                          	FileURI *string `json:"fileUri,omitempty"`
                                                                                                          }

                                                                                                            FileDTO DTO to hold details of uploaded files.

                                                                                                            type InnerErrorModel

                                                                                                            type InnerErrorModel struct {
                                                                                                            	// Code - A more specific error code than was provided by the containing error.
                                                                                                            	Code *string `json:"code,omitempty"`
                                                                                                            	// InnerError - An object containing more specific information than the current object about the error.
                                                                                                            	InnerError *InnerErrorModel `json:"innerError,omitempty"`
                                                                                                            }

                                                                                                              InnerErrorModel an object containing more specific information about the error. As per Microsoft One API guidelines - https://github.com/Microsoft/api-guidelines/blob/vNext/Guidelines.md#7102-error-condition-responses.

                                                                                                              type KnowledgebaseClient

                                                                                                              type KnowledgebaseClient struct {
                                                                                                              	BaseClient
                                                                                                              }

                                                                                                                KnowledgebaseClient is the an API for QnAMaker Service

                                                                                                                func NewKnowledgebaseClient

                                                                                                                func NewKnowledgebaseClient(endpoint string) KnowledgebaseClient

                                                                                                                  NewKnowledgebaseClient creates an instance of the KnowledgebaseClient client.

                                                                                                                  func (KnowledgebaseClient) Create

                                                                                                                  func (client KnowledgebaseClient) Create(ctx context.Context, createKbPayload CreateKbDTO) (result Operation, err error)

                                                                                                                    Create sends the create request. Parameters: createKbPayload - post body of the request.

                                                                                                                    func (KnowledgebaseClient) CreatePreparer

                                                                                                                    func (client KnowledgebaseClient) CreatePreparer(ctx context.Context, createKbPayload CreateKbDTO) (*http.Request, error)

                                                                                                                      CreatePreparer prepares the Create request.

                                                                                                                      func (KnowledgebaseClient) CreateResponder

                                                                                                                      func (client KnowledgebaseClient) CreateResponder(resp *http.Response) (result Operation, err error)

                                                                                                                        CreateResponder handles the response to the Create request. The method always closes the http.Response Body.

                                                                                                                        func (KnowledgebaseClient) CreateSender

                                                                                                                        func (client KnowledgebaseClient) CreateSender(req *http.Request) (*http.Response, error)

                                                                                                                          CreateSender sends the Create request. The method will close the http.Response Body if it receives an error.

                                                                                                                          func (KnowledgebaseClient) Delete

                                                                                                                          func (client KnowledgebaseClient) Delete(ctx context.Context, kbID string) (result autorest.Response, err error)

                                                                                                                            Delete sends the delete request. Parameters: kbID - knowledgebase id.

                                                                                                                            func (KnowledgebaseClient) DeletePreparer

                                                                                                                            func (client KnowledgebaseClient) DeletePreparer(ctx context.Context, kbID string) (*http.Request, error)

                                                                                                                              DeletePreparer prepares the Delete request.

                                                                                                                              func (KnowledgebaseClient) DeleteResponder

                                                                                                                              func (client KnowledgebaseClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error)

                                                                                                                                DeleteResponder handles the response to the Delete request. The method always closes the http.Response Body.

                                                                                                                                func (KnowledgebaseClient) DeleteSender

                                                                                                                                func (client KnowledgebaseClient) DeleteSender(req *http.Request) (*http.Response, error)

                                                                                                                                  DeleteSender sends the Delete request. The method will close the http.Response Body if it receives an error.

                                                                                                                                  func (KnowledgebaseClient) Download

                                                                                                                                  func (client KnowledgebaseClient) Download(ctx context.Context, kbID string, environment EnvironmentType, source string, changedSince string) (result QnADocumentsDTO, err error)

                                                                                                                                    Download sends the download request. Parameters: kbID - knowledgebase id. environment - specifies whether environment is Test or Prod. source - the source property filter to apply. Sample value: Editorial, smartLight%20FAQ.tsv . changedSince - changedSince property is used to return all QnAs created or updated after a specific time duration. The user can filter QnAs by seconds (s), minutes (m), hours (h) and days (d). The user may use any integral value along with the suffix for time. For instance, the value of 5m returns all QnA pairs updated or created in the last 5 minutes.

                                                                                                                                    func (KnowledgebaseClient) DownloadPreparer

                                                                                                                                    func (client KnowledgebaseClient) DownloadPreparer(ctx context.Context, kbID string, environment EnvironmentType, source string, changedSince string) (*http.Request, error)

                                                                                                                                      DownloadPreparer prepares the Download request.

                                                                                                                                      func (KnowledgebaseClient) DownloadResponder

                                                                                                                                      func (client KnowledgebaseClient) DownloadResponder(resp *http.Response) (result QnADocumentsDTO, err error)

                                                                                                                                        DownloadResponder handles the response to the Download request. The method always closes the http.Response Body.

                                                                                                                                        func (KnowledgebaseClient) DownloadSender

                                                                                                                                        func (client KnowledgebaseClient) DownloadSender(req *http.Request) (*http.Response, error)

                                                                                                                                          DownloadSender sends the Download request. The method will close the http.Response Body if it receives an error.

                                                                                                                                          func (KnowledgebaseClient) GetDetails

                                                                                                                                          func (client KnowledgebaseClient) GetDetails(ctx context.Context, kbID string) (result KnowledgebaseDTO, err error)

                                                                                                                                            GetDetails sends the get details request. Parameters: kbID - knowledgebase id.

                                                                                                                                            func (KnowledgebaseClient) GetDetailsPreparer

                                                                                                                                            func (client KnowledgebaseClient) GetDetailsPreparer(ctx context.Context, kbID string) (*http.Request, error)

                                                                                                                                              GetDetailsPreparer prepares the GetDetails request.

                                                                                                                                              func (KnowledgebaseClient) GetDetailsResponder

                                                                                                                                              func (client KnowledgebaseClient) GetDetailsResponder(resp *http.Response) (result KnowledgebaseDTO, err error)

                                                                                                                                                GetDetailsResponder handles the response to the GetDetails request. The method always closes the http.Response Body.

                                                                                                                                                func (KnowledgebaseClient) GetDetailsSender

                                                                                                                                                func (client KnowledgebaseClient) GetDetailsSender(req *http.Request) (*http.Response, error)

                                                                                                                                                  GetDetailsSender sends the GetDetails request. The method will close the http.Response Body if it receives an error.

                                                                                                                                                  func (KnowledgebaseClient) ListAll

                                                                                                                                                  func (client KnowledgebaseClient) ListAll(ctx context.Context) (result KnowledgebasesDTO, err error)

                                                                                                                                                    ListAll sends the list all request.

                                                                                                                                                    func (KnowledgebaseClient) ListAllPreparer

                                                                                                                                                    func (client KnowledgebaseClient) ListAllPreparer(ctx context.Context) (*http.Request, error)

                                                                                                                                                      ListAllPreparer prepares the ListAll request.

                                                                                                                                                      func (KnowledgebaseClient) ListAllResponder

                                                                                                                                                      func (client KnowledgebaseClient) ListAllResponder(resp *http.Response) (result KnowledgebasesDTO, err error)

                                                                                                                                                        ListAllResponder handles the response to the ListAll request. The method always closes the http.Response Body.

                                                                                                                                                        func (KnowledgebaseClient) ListAllSender

                                                                                                                                                        func (client KnowledgebaseClient) ListAllSender(req *http.Request) (*http.Response, error)

                                                                                                                                                          ListAllSender sends the ListAll request. The method will close the http.Response Body if it receives an error.

                                                                                                                                                          func (KnowledgebaseClient) Publish

                                                                                                                                                          func (client KnowledgebaseClient) Publish(ctx context.Context, kbID string) (result autorest.Response, err error)

                                                                                                                                                            Publish sends the publish request. Parameters: kbID - knowledgebase id.

                                                                                                                                                            func (KnowledgebaseClient) PublishPreparer

                                                                                                                                                            func (client KnowledgebaseClient) PublishPreparer(ctx context.Context, kbID string) (*http.Request, error)

                                                                                                                                                              PublishPreparer prepares the Publish request.

                                                                                                                                                              func (KnowledgebaseClient) PublishResponder

                                                                                                                                                              func (client KnowledgebaseClient) PublishResponder(resp *http.Response) (result autorest.Response, err error)

                                                                                                                                                                PublishResponder handles the response to the Publish request. The method always closes the http.Response Body.

                                                                                                                                                                func (KnowledgebaseClient) PublishSender

                                                                                                                                                                func (client KnowledgebaseClient) PublishSender(req *http.Request) (*http.Response, error)

                                                                                                                                                                  PublishSender sends the Publish request. The method will close the http.Response Body if it receives an error.

                                                                                                                                                                  func (KnowledgebaseClient) Replace

                                                                                                                                                                  func (client KnowledgebaseClient) Replace(ctx context.Context, kbID string, replaceKb ReplaceKbDTO) (result autorest.Response, err error)

                                                                                                                                                                    Replace sends the replace request. Parameters: kbID - knowledgebase id. replaceKb - an instance of ReplaceKbDTO which contains list of qnas to be uploaded

                                                                                                                                                                    func (KnowledgebaseClient) ReplacePreparer

                                                                                                                                                                    func (client KnowledgebaseClient) ReplacePreparer(ctx context.Context, kbID string, replaceKb ReplaceKbDTO) (*http.Request, error)

                                                                                                                                                                      ReplacePreparer prepares the Replace request.

                                                                                                                                                                      func (KnowledgebaseClient) ReplaceResponder

                                                                                                                                                                      func (client KnowledgebaseClient) ReplaceResponder(resp *http.Response) (result autorest.Response, err error)

                                                                                                                                                                        ReplaceResponder handles the response to the Replace request. The method always closes the http.Response Body.

                                                                                                                                                                        func (KnowledgebaseClient) ReplaceSender

                                                                                                                                                                        func (client KnowledgebaseClient) ReplaceSender(req *http.Request) (*http.Response, error)

                                                                                                                                                                          ReplaceSender sends the Replace request. The method will close the http.Response Body if it receives an error.

                                                                                                                                                                          func (KnowledgebaseClient) Update

                                                                                                                                                                          func (client KnowledgebaseClient) Update(ctx context.Context, kbID string, updateKb UpdateKbOperationDTO) (result Operation, err error)

                                                                                                                                                                            Update sends the update request. Parameters: kbID - knowledgebase id. updateKb - post body of the request.

                                                                                                                                                                            func (KnowledgebaseClient) UpdatePreparer

                                                                                                                                                                            func (client KnowledgebaseClient) UpdatePreparer(ctx context.Context, kbID string, updateKb UpdateKbOperationDTO) (*http.Request, error)

                                                                                                                                                                              UpdatePreparer prepares the Update request.

                                                                                                                                                                              func (KnowledgebaseClient) UpdateResponder

                                                                                                                                                                              func (client KnowledgebaseClient) UpdateResponder(resp *http.Response) (result Operation, err error)

                                                                                                                                                                                UpdateResponder handles the response to the Update request. The method always closes the http.Response Body.

                                                                                                                                                                                func (KnowledgebaseClient) UpdateSender

                                                                                                                                                                                func (client KnowledgebaseClient) UpdateSender(req *http.Request) (*http.Response, error)

                                                                                                                                                                                  UpdateSender sends the Update request. The method will close the http.Response Body if it receives an error.

                                                                                                                                                                                  type KnowledgebaseDTO

                                                                                                                                                                                  type KnowledgebaseDTO struct {
                                                                                                                                                                                  	autorest.Response `json:"-"`
                                                                                                                                                                                  	// ID - Unique id that identifies a knowledgebase.
                                                                                                                                                                                  	ID *string `json:"id,omitempty"`
                                                                                                                                                                                  	// HostName - URL host name at which the knowledgebase is hosted.
                                                                                                                                                                                  	HostName *string `json:"hostName,omitempty"`
                                                                                                                                                                                  	// LastAccessedTimestamp - Time stamp at which the knowledgebase was last accessed (UTC).
                                                                                                                                                                                  	LastAccessedTimestamp *string `json:"lastAccessedTimestamp,omitempty"`
                                                                                                                                                                                  	// LastChangedTimestamp - Time stamp at which the knowledgebase was last modified (UTC).
                                                                                                                                                                                  	LastChangedTimestamp *string `json:"lastChangedTimestamp,omitempty"`
                                                                                                                                                                                  	// LastPublishedTimestamp - Time stamp at which the knowledgebase was last published (UTC).
                                                                                                                                                                                  	LastPublishedTimestamp *string `json:"lastPublishedTimestamp,omitempty"`
                                                                                                                                                                                  	// Name - Friendly name of the knowledgebase.
                                                                                                                                                                                  	Name *string `json:"name,omitempty"`
                                                                                                                                                                                  	// UserID - User who created / owns the knowledgebase.
                                                                                                                                                                                  	UserID *string `json:"userId,omitempty"`
                                                                                                                                                                                  	// Urls - URL sources from which Q-A were extracted and added to the knowledgebase.
                                                                                                                                                                                  	Urls *[]string `json:"urls,omitempty"`
                                                                                                                                                                                  	// Sources - Custom sources from which Q-A were extracted or explicitly added to the knowledgebase.
                                                                                                                                                                                  	Sources *[]string `json:"sources,omitempty"`
                                                                                                                                                                                  }

                                                                                                                                                                                    KnowledgebaseDTO response schema for CreateKb operation.

                                                                                                                                                                                    type KnowledgebasesDTO

                                                                                                                                                                                    type KnowledgebasesDTO struct {
                                                                                                                                                                                    	autorest.Response `json:"-"`
                                                                                                                                                                                    	// Knowledgebases - Collection of knowledgebase records.
                                                                                                                                                                                    	Knowledgebases *[]KnowledgebaseDTO `json:"knowledgebases,omitempty"`
                                                                                                                                                                                    }

                                                                                                                                                                                      KnowledgebasesDTO collection of knowledgebases owned by a user.

                                                                                                                                                                                      type MetadataDTO

                                                                                                                                                                                      type MetadataDTO struct {
                                                                                                                                                                                      	// Name - Metadata name.
                                                                                                                                                                                      	Name *string `json:"name,omitempty"`
                                                                                                                                                                                      	// Value - Metadata value.
                                                                                                                                                                                      	Value *string `json:"value,omitempty"`
                                                                                                                                                                                      }

                                                                                                                                                                                        MetadataDTO name - value pair of metadata.

                                                                                                                                                                                        type Operation

                                                                                                                                                                                        type Operation struct {
                                                                                                                                                                                        	autorest.Response `json:"-"`
                                                                                                                                                                                        	// OperationState - Operation state. Possible values include: 'Failed', 'NotStarted', 'Running', 'Succeeded'
                                                                                                                                                                                        	OperationState OperationStateType `json:"operationState,omitempty"`
                                                                                                                                                                                        	// CreatedTimestamp - Timestamp when the operation was created.
                                                                                                                                                                                        	CreatedTimestamp *string `json:"createdTimestamp,omitempty"`
                                                                                                                                                                                        	// LastActionTimestamp - Timestamp when the current state was entered.
                                                                                                                                                                                        	LastActionTimestamp *string `json:"lastActionTimestamp,omitempty"`
                                                                                                                                                                                        	// ResourceLocation - Relative URI to the target resource location for completed resources.
                                                                                                                                                                                        	ResourceLocation *string `json:"resourceLocation,omitempty"`
                                                                                                                                                                                        	// UserID - User Id
                                                                                                                                                                                        	UserID *string `json:"userId,omitempty"`
                                                                                                                                                                                        	// OperationID - Operation Id.
                                                                                                                                                                                        	OperationID *string `json:"operationId,omitempty"`
                                                                                                                                                                                        	// ErrorResponse - Error details in case of failures.
                                                                                                                                                                                        	ErrorResponse *ErrorResponse `json:"errorResponse,omitempty"`
                                                                                                                                                                                        }

                                                                                                                                                                                          Operation record to track long running operation.

                                                                                                                                                                                          type OperationStateType

                                                                                                                                                                                          type OperationStateType string

                                                                                                                                                                                            OperationStateType enumerates the values for operation state type.

                                                                                                                                                                                            const (
                                                                                                                                                                                            	// Failed ...
                                                                                                                                                                                            	Failed OperationStateType = "Failed"
                                                                                                                                                                                            	// NotStarted ...
                                                                                                                                                                                            	NotStarted OperationStateType = "NotStarted"
                                                                                                                                                                                            	// Running ...
                                                                                                                                                                                            	Running OperationStateType = "Running"
                                                                                                                                                                                            	// Succeeded ...
                                                                                                                                                                                            	Succeeded OperationStateType = "Succeeded"
                                                                                                                                                                                            )

                                                                                                                                                                                            func PossibleOperationStateTypeValues

                                                                                                                                                                                            func PossibleOperationStateTypeValues() []OperationStateType

                                                                                                                                                                                              PossibleOperationStateTypeValues returns an array of possible values for the OperationStateType const type.

                                                                                                                                                                                              type OperationsClient

                                                                                                                                                                                              type OperationsClient struct {
                                                                                                                                                                                              	BaseClient
                                                                                                                                                                                              }

                                                                                                                                                                                                OperationsClient is the an API for QnAMaker Service

                                                                                                                                                                                                func NewOperationsClient

                                                                                                                                                                                                func NewOperationsClient(endpoint string) OperationsClient

                                                                                                                                                                                                  NewOperationsClient creates an instance of the OperationsClient client.

                                                                                                                                                                                                  func (OperationsClient) GetDetails

                                                                                                                                                                                                  func (client OperationsClient) GetDetails(ctx context.Context, operationID string) (result Operation, err error)

                                                                                                                                                                                                    GetDetails sends the get details request. Parameters: operationID - operation id.

                                                                                                                                                                                                    func (OperationsClient) GetDetailsPreparer

                                                                                                                                                                                                    func (client OperationsClient) GetDetailsPreparer(ctx context.Context, operationID string) (*http.Request, error)

                                                                                                                                                                                                      GetDetailsPreparer prepares the GetDetails request.

                                                                                                                                                                                                      func (OperationsClient) GetDetailsResponder

                                                                                                                                                                                                      func (client OperationsClient) GetDetailsResponder(resp *http.Response) (result Operation, err error)

                                                                                                                                                                                                        GetDetailsResponder handles the response to the GetDetails request. The method always closes the http.Response Body.

                                                                                                                                                                                                        func (OperationsClient) GetDetailsSender

                                                                                                                                                                                                        func (client OperationsClient) GetDetailsSender(req *http.Request) (*http.Response, error)

                                                                                                                                                                                                          GetDetailsSender sends the GetDetails request. The method will close the http.Response Body if it receives an error.

                                                                                                                                                                                                          type PromptDTO

                                                                                                                                                                                                          type PromptDTO struct {
                                                                                                                                                                                                          	// DisplayOrder - Index of the prompt - used in ordering of the prompts
                                                                                                                                                                                                          	DisplayOrder *int32 `json:"displayOrder,omitempty"`
                                                                                                                                                                                                          	// QnaID - Qna id corresponding to the prompt - if QnaId is present, QnADTO object is ignored.
                                                                                                                                                                                                          	QnaID *int32 `json:"qnaId,omitempty"`
                                                                                                                                                                                                          	// Qna - QnADTO - Either QnaId or QnADTO needs to be present in a PromptDTO object
                                                                                                                                                                                                          	Qna *PromptDTOQna `json:"qna,omitempty"`
                                                                                                                                                                                                          	// DisplayText - Text displayed to represent a follow up question prompt
                                                                                                                                                                                                          	DisplayText *string `json:"displayText,omitempty"`
                                                                                                                                                                                                          }

                                                                                                                                                                                                            PromptDTO prompt for an answer.

                                                                                                                                                                                                            type PromptDTOQna

                                                                                                                                                                                                            type PromptDTOQna struct {
                                                                                                                                                                                                            	// ID - Unique id for the Q-A.
                                                                                                                                                                                                            	ID *int32 `json:"id,omitempty"`
                                                                                                                                                                                                            	// Answer - Answer text
                                                                                                                                                                                                            	Answer *string `json:"answer,omitempty"`
                                                                                                                                                                                                            	// Source - Source from which Q-A was indexed. eg. https://docs.microsoft.com/en-us/azure/cognitive-services/QnAMaker/FAQs
                                                                                                                                                                                                            	Source *string `json:"source,omitempty"`
                                                                                                                                                                                                            	// Questions - List of questions associated with the answer.
                                                                                                                                                                                                            	Questions *[]string `json:"questions,omitempty"`
                                                                                                                                                                                                            	// Metadata - List of metadata associated with the answer.
                                                                                                                                                                                                            	Metadata *[]MetadataDTO `json:"metadata,omitempty"`
                                                                                                                                                                                                            	// Context - Context of a QnA
                                                                                                                                                                                                            	Context *QnADTOContext `json:"context,omitempty"`
                                                                                                                                                                                                            }

                                                                                                                                                                                                              PromptDTOQna qnADTO - Either QnaId or QnADTO needs to be present in a PromptDTO object

                                                                                                                                                                                                              type QnADTO

                                                                                                                                                                                                              type QnADTO struct {
                                                                                                                                                                                                              	// ID - Unique id for the Q-A.
                                                                                                                                                                                                              	ID *int32 `json:"id,omitempty"`
                                                                                                                                                                                                              	// Answer - Answer text
                                                                                                                                                                                                              	Answer *string `json:"answer,omitempty"`
                                                                                                                                                                                                              	// Source - Source from which Q-A was indexed. eg. https://docs.microsoft.com/en-us/azure/cognitive-services/QnAMaker/FAQs
                                                                                                                                                                                                              	Source *string `json:"source,omitempty"`
                                                                                                                                                                                                              	// Questions - List of questions associated with the answer.
                                                                                                                                                                                                              	Questions *[]string `json:"questions,omitempty"`
                                                                                                                                                                                                              	// Metadata - List of metadata associated with the answer.
                                                                                                                                                                                                              	Metadata *[]MetadataDTO `json:"metadata,omitempty"`
                                                                                                                                                                                                              	// Context - Context of a QnA
                                                                                                                                                                                                              	Context *QnADTOContext `json:"context,omitempty"`
                                                                                                                                                                                                              }

                                                                                                                                                                                                                QnADTO q-A object.

                                                                                                                                                                                                                type QnADTOContext

                                                                                                                                                                                                                type QnADTOContext struct {
                                                                                                                                                                                                                	// IsContextOnly - To mark if a prompt is relevant only with a previous question or not.
                                                                                                                                                                                                                	// true - Do not include this QnA as search result for queries without context
                                                                                                                                                                                                                	// false - ignores context and includes this QnA in search result
                                                                                                                                                                                                                	IsContextOnly *bool `json:"isContextOnly,omitempty"`
                                                                                                                                                                                                                	// Prompts - List of prompts associated with the answer.
                                                                                                                                                                                                                	Prompts *[]PromptDTO `json:"prompts,omitempty"`
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  QnADTOContext context of a QnA

                                                                                                                                                                                                                  type QnADocumentsDTO

                                                                                                                                                                                                                  type QnADocumentsDTO struct {
                                                                                                                                                                                                                  	autorest.Response `json:"-"`
                                                                                                                                                                                                                  	// QnaDocuments - List of answers.
                                                                                                                                                                                                                  	QnaDocuments *[]QnADTO `json:"qnaDocuments,omitempty"`
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    QnADocumentsDTO list of QnADTO

                                                                                                                                                                                                                    type ReplaceKbDTO

                                                                                                                                                                                                                    type ReplaceKbDTO struct {
                                                                                                                                                                                                                    	// QnAList - List of Q-A (QnADTO) to be added to the knowledgebase. Q-A Ids are assigned by the service and should be omitted.
                                                                                                                                                                                                                    	QnAList *[]QnADTO `json:"qnAList,omitempty"`
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      ReplaceKbDTO post body schema for Replace KB operation.

                                                                                                                                                                                                                      type UpdateContextDTO

                                                                                                                                                                                                                      type UpdateContextDTO struct {
                                                                                                                                                                                                                      	// PromptsToDelete - List of prompts associated with qna to be deleted
                                                                                                                                                                                                                      	PromptsToDelete *[]int32 `json:"promptsToDelete,omitempty"`
                                                                                                                                                                                                                      	// PromptsToAdd - List of prompts to be added to the qna.
                                                                                                                                                                                                                      	PromptsToAdd *[]PromptDTO `json:"promptsToAdd,omitempty"`
                                                                                                                                                                                                                      	// IsContextOnly - To mark if a prompt is relevant only with a previous question or not.
                                                                                                                                                                                                                      	// true - Do not include this QnA as search result for queries without context
                                                                                                                                                                                                                      	// false - ignores context and includes this QnA in search result
                                                                                                                                                                                                                      	IsContextOnly *bool `json:"isContextOnly,omitempty"`
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        UpdateContextDTO update Body schema to represent context to be updated

                                                                                                                                                                                                                        type UpdateKbContentsDTO

                                                                                                                                                                                                                        type UpdateKbContentsDTO struct {
                                                                                                                                                                                                                        	// Name - Friendly name for the knowledgebase.
                                                                                                                                                                                                                        	Name *string `json:"name,omitempty"`
                                                                                                                                                                                                                        	// QnaList - List of Q-A (UpdateQnaDTO) to be added to the knowledgebase.
                                                                                                                                                                                                                        	QnaList *[]UpdateQnaDTO `json:"qnaList,omitempty"`
                                                                                                                                                                                                                        	// Urls - List of existing URLs to be refreshed. The content will be extracted again and re-indexed.
                                                                                                                                                                                                                        	Urls *[]string `json:"urls,omitempty"`
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          UpdateKbContentsDTO PATCH body schema for Update operation in Update Kb

                                                                                                                                                                                                                          type UpdateKbOperationDTO

                                                                                                                                                                                                                          type UpdateKbOperationDTO struct {
                                                                                                                                                                                                                          	// Add - An instance of CreateKbInputDTO for add operation
                                                                                                                                                                                                                          	Add *UpdateKbOperationDTOAdd `json:"add,omitempty"`
                                                                                                                                                                                                                          	// Delete - An instance of DeleteKbContentsDTO for delete Operation
                                                                                                                                                                                                                          	Delete *UpdateKbOperationDTODelete `json:"delete,omitempty"`
                                                                                                                                                                                                                          	// Update - An instance of UpdateKbContentsDTO for Update Operation
                                                                                                                                                                                                                          	Update *UpdateKbOperationDTOUpdate `json:"update,omitempty"`
                                                                                                                                                                                                                          	// EnableHierarchicalExtraction - Enable hierarchical extraction of Q-A from files and urls. The value set during KB creation will be used if this field is not present.
                                                                                                                                                                                                                          	EnableHierarchicalExtraction *bool `json:"enableHierarchicalExtraction,omitempty"`
                                                                                                                                                                                                                          	// DefaultAnswerUsedForExtraction - Text string to be used as the answer in any Q-A which has no extracted answer from the document but has a hierarchy. Required when EnableHierarchicalExtraction field is set to True.
                                                                                                                                                                                                                          	DefaultAnswerUsedForExtraction *string `json:"defaultAnswerUsedForExtraction,omitempty"`
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            UpdateKbOperationDTO contains list of QnAs to be updated

                                                                                                                                                                                                                            type UpdateKbOperationDTOAdd

                                                                                                                                                                                                                            type UpdateKbOperationDTOAdd struct {
                                                                                                                                                                                                                            	// QnaList - List of QNA to be added to the index. Ids are generated by the service and should be omitted.
                                                                                                                                                                                                                            	QnaList *[]QnADTO `json:"qnaList,omitempty"`
                                                                                                                                                                                                                            	// Urls - List of URLs to be added to knowledgebase.
                                                                                                                                                                                                                            	Urls *[]string `json:"urls,omitempty"`
                                                                                                                                                                                                                            	// Files - List of files to be added to knowledgebase.
                                                                                                                                                                                                                            	Files *[]FileDTO `json:"files,omitempty"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              UpdateKbOperationDTOAdd an instance of CreateKbInputDTO for add operation

                                                                                                                                                                                                                              type UpdateKbOperationDTODelete

                                                                                                                                                                                                                              type UpdateKbOperationDTODelete struct {
                                                                                                                                                                                                                              	// Ids - List of Qna Ids to be deleted
                                                                                                                                                                                                                              	Ids *[]int32 `json:"ids,omitempty"`
                                                                                                                                                                                                                              	// Sources - List of sources to be deleted from knowledgebase.
                                                                                                                                                                                                                              	Sources *[]string `json:"sources,omitempty"`
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                UpdateKbOperationDTODelete an instance of DeleteKbContentsDTO for delete Operation

                                                                                                                                                                                                                                type UpdateKbOperationDTOUpdate

                                                                                                                                                                                                                                type UpdateKbOperationDTOUpdate struct {
                                                                                                                                                                                                                                	// Name - Friendly name for the knowledgebase.
                                                                                                                                                                                                                                	Name *string `json:"name,omitempty"`
                                                                                                                                                                                                                                	// QnaList - List of Q-A (UpdateQnaDTO) to be added to the knowledgebase.
                                                                                                                                                                                                                                	QnaList *[]UpdateQnaDTO `json:"qnaList,omitempty"`
                                                                                                                                                                                                                                	// Urls - List of existing URLs to be refreshed. The content will be extracted again and re-indexed.
                                                                                                                                                                                                                                	Urls *[]string `json:"urls,omitempty"`
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  UpdateKbOperationDTOUpdate an instance of UpdateKbContentsDTO for Update Operation

                                                                                                                                                                                                                                  type UpdateMetadataDTO

                                                                                                                                                                                                                                  type UpdateMetadataDTO struct {
                                                                                                                                                                                                                                  	// Delete - List of Metadata associated with answer to be deleted
                                                                                                                                                                                                                                  	Delete *[]MetadataDTO `json:"delete,omitempty"`
                                                                                                                                                                                                                                  	// Add - List of metadata associated with answer to be added
                                                                                                                                                                                                                                  	Add *[]MetadataDTO `json:"add,omitempty"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    UpdateMetadataDTO PATCH Body schema to represent list of Metadata to be updated

                                                                                                                                                                                                                                    type UpdateQnaDTO

                                                                                                                                                                                                                                    type UpdateQnaDTO struct {
                                                                                                                                                                                                                                    	// ID - Unique id for the Q-A
                                                                                                                                                                                                                                    	ID *int32 `json:"id,omitempty"`
                                                                                                                                                                                                                                    	// Answer - Answer text
                                                                                                                                                                                                                                    	Answer *string `json:"answer,omitempty"`
                                                                                                                                                                                                                                    	// Source - Source from which Q-A was indexed. eg. https://docs.microsoft.com/en-us/azure/cognitive-services/QnAMaker/FAQs
                                                                                                                                                                                                                                    	Source *string `json:"source,omitempty"`
                                                                                                                                                                                                                                    	// Questions - List of questions associated with the answer.
                                                                                                                                                                                                                                    	Questions *UpdateQnaDTOQuestions `json:"questions,omitempty"`
                                                                                                                                                                                                                                    	// Metadata - List of metadata associated with the answer to be updated
                                                                                                                                                                                                                                    	Metadata *UpdateQnaDTOMetadata `json:"metadata,omitempty"`
                                                                                                                                                                                                                                    	// Context - Context associated with Qna to be updated.
                                                                                                                                                                                                                                    	Context *UpdateQnaDTOContext `json:"context,omitempty"`
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      UpdateQnaDTO PATCH Body schema for Update Qna List

                                                                                                                                                                                                                                      type UpdateQnaDTOContext

                                                                                                                                                                                                                                      type UpdateQnaDTOContext struct {
                                                                                                                                                                                                                                      	// PromptsToDelete - List of prompts associated with qna to be deleted
                                                                                                                                                                                                                                      	PromptsToDelete *[]int32 `json:"promptsToDelete,omitempty"`
                                                                                                                                                                                                                                      	// PromptsToAdd - List of prompts to be added to the qna.
                                                                                                                                                                                                                                      	PromptsToAdd *[]PromptDTO `json:"promptsToAdd,omitempty"`
                                                                                                                                                                                                                                      	// IsContextOnly - To mark if a prompt is relevant only with a previous question or not.
                                                                                                                                                                                                                                      	// true - Do not include this QnA as search result for queries without context
                                                                                                                                                                                                                                      	// false - ignores context and includes this QnA in search result
                                                                                                                                                                                                                                      	IsContextOnly *bool `json:"isContextOnly,omitempty"`
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        UpdateQnaDTOContext context associated with Qna to be updated.

                                                                                                                                                                                                                                        type UpdateQnaDTOMetadata

                                                                                                                                                                                                                                        type UpdateQnaDTOMetadata struct {
                                                                                                                                                                                                                                        	// Delete - List of Metadata associated with answer to be deleted
                                                                                                                                                                                                                                        	Delete *[]MetadataDTO `json:"delete,omitempty"`
                                                                                                                                                                                                                                        	// Add - List of metadata associated with answer to be added
                                                                                                                                                                                                                                        	Add *[]MetadataDTO `json:"add,omitempty"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          UpdateQnaDTOMetadata list of metadata associated with the answer to be updated

                                                                                                                                                                                                                                          type UpdateQnaDTOQuestions

                                                                                                                                                                                                                                          type UpdateQnaDTOQuestions struct {
                                                                                                                                                                                                                                          	// Add - List of questions to be added
                                                                                                                                                                                                                                          	Add *[]string `json:"add,omitempty"`
                                                                                                                                                                                                                                          	// Delete - List of questions to be deleted.
                                                                                                                                                                                                                                          	Delete *[]string `json:"delete,omitempty"`
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            UpdateQnaDTOQuestions list of questions associated with the answer.

                                                                                                                                                                                                                                            type UpdateQuestionsDTO

                                                                                                                                                                                                                                            type UpdateQuestionsDTO struct {
                                                                                                                                                                                                                                            	// Add - List of questions to be added
                                                                                                                                                                                                                                            	Add *[]string `json:"add,omitempty"`
                                                                                                                                                                                                                                            	// Delete - List of questions to be deleted.
                                                                                                                                                                                                                                            	Delete *[]string `json:"delete,omitempty"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              UpdateQuestionsDTO PATCH Body schema for Update Kb which contains list of questions to be added and deleted

                                                                                                                                                                                                                                              type WordAlterationsDTO

                                                                                                                                                                                                                                              type WordAlterationsDTO struct {
                                                                                                                                                                                                                                              	autorest.Response `json:"-"`
                                                                                                                                                                                                                                              	// WordAlterations - Collection of word alterations.
                                                                                                                                                                                                                                              	WordAlterations *[]AlterationsDTO `json:"wordAlterations,omitempty"`
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                WordAlterationsDTO collection of word alterations.

                                                                                                                                                                                                                                                Directories

                                                                                                                                                                                                                                                Path Synopsis