googleapis
Version:
Google APIs Client Library for Node.js
994 lines • 1.79 MB
TypeScript
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace dialogflow_v2beta1 {
export interface Options extends GlobalOptions {
version: 'v2beta1';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* Dialogflow API
*
* Builds conversational interfaces (for example, chatbots, and voice-powered apps and devices).
*
* @example
* ```js
* const {google} = require('googleapis');
* const dialogflow = google.dialogflow('v2beta1');
* ```
*/
export class Dialogflow {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Hierarchical advanced settings for agent/flow/page/fulfillment/parameter. Settings exposed at lower level overrides the settings exposed at higher level. Overriding occurs at the sub-setting level. For example, the playback_interruption_settings at fulfillment level only overrides the playback_interruption_settings at the agent level, leaving other settings at the agent level unchanged. DTMF settings does not override each other. DTMF settings set at different levels define DTMF detections running in parallel. Hierarchy: Agent-\>Flow-\>Page-\>Fulfillment/Parameter.
*/
export interface Schema$GoogleCloudDialogflowCxV3AdvancedSettings {
/**
* If present, incoming audio is exported by Dialogflow to the configured Google Cloud Storage destination. Exposed at the following levels: - Agent level - Flow level
*/
audioExportGcsDestination?: Schema$GoogleCloudDialogflowCxV3GcsDestination;
/**
* Settings for DTMF. Exposed at the following levels: - Agent level - Flow level - Page level - Parameter level.
*/
dtmfSettings?: Schema$GoogleCloudDialogflowCxV3AdvancedSettingsDtmfSettings;
/**
* Settings for logging. Settings for Dialogflow History, Contact Center messages, StackDriver logs, and speech logging. Exposed at the following levels: - Agent level.
*/
loggingSettings?: Schema$GoogleCloudDialogflowCxV3AdvancedSettingsLoggingSettings;
/**
* Settings for speech to text detection. Exposed at the following levels: - Agent level - Flow level - Page level - Parameter level
*/
speechSettings?: Schema$GoogleCloudDialogflowCxV3AdvancedSettingsSpeechSettings;
}
/**
* Define behaviors for DTMF (dual tone multi frequency).
*/
export interface Schema$GoogleCloudDialogflowCxV3AdvancedSettingsDtmfSettings {
/**
* If true, incoming audio is processed for DTMF (dual tone multi frequency) events. For example, if the caller presses a button on their telephone keypad and DTMF processing is enabled, Dialogflow will detect the event (e.g. a "3" was pressed) in the incoming audio and pass the event to the bot to drive business logic (e.g. when 3 is pressed, return the account balance).
*/
enabled?: boolean | null;
/**
* Endpoint timeout setting for matching dtmf input to regex.
*/
endpointingTimeoutDuration?: string | null;
/**
* The digit that terminates a DTMF digit sequence.
*/
finishDigit?: string | null;
/**
* Interdigit timeout setting for matching dtmf input to regex.
*/
interdigitTimeoutDuration?: string | null;
/**
* Max length of DTMF digits.
*/
maxDigits?: number | null;
}
/**
* Define behaviors on logging.
*/
export interface Schema$GoogleCloudDialogflowCxV3AdvancedSettingsLoggingSettings {
/**
* Enables consent-based end-user input redaction, if true, a pre-defined session parameter `$session.params.conversation-redaction` will be used to determine if the utterance should be redacted.
*/
enableConsentBasedRedaction?: boolean | null;
/**
* Enables DF Interaction logging.
*/
enableInteractionLogging?: boolean | null;
/**
* Enables Google Cloud Logging.
*/
enableStackdriverLogging?: boolean | null;
}
/**
* Define behaviors of speech to text detection.
*/
export interface Schema$GoogleCloudDialogflowCxV3AdvancedSettingsSpeechSettings {
/**
* Sensitivity of the speech model that detects the end of speech. Scale from 0 to 100.
*/
endpointerSensitivity?: number | null;
/**
* Mapping from language to Speech-to-Text model. The mapped Speech-to-Text model will be selected for requests from its corresponding language. For more information, see [Speech models](https://cloud.google.com/dialogflow/cx/docs/concept/speech-models).
*/
models?: {
[key: string]: string;
} | null;
/**
* Timeout before detecting no speech.
*/
noSpeechTimeout?: string | null;
/**
* Use timeout based endpointing, interpreting endpointer sensitivity as seconds of timeout value.
*/
useTimeoutBasedEndpointing?: boolean | null;
}
/**
* Represents the natural speech audio to be processed.
*/
export interface Schema$GoogleCloudDialogflowCxV3AudioInput {
/**
* The natural language speech audio to be processed. A single request can contain up to 2 minutes of speech audio data. The transcribed text cannot contain more than 256 bytes. For non-streaming audio detect intent, both `config` and `audio` must be provided. For streaming audio detect intent, `config` must be provided in the first request and `audio` must be provided in all following requests.
*/
audio?: string | null;
/**
* Required. Instructs the speech recognizer how to process the speech audio.
*/
config?: Schema$GoogleCloudDialogflowCxV3InputAudioConfig;
}
/**
* Configuration of the barge-in behavior. Barge-in instructs the API to return a detected utterance at a proper time while the client is playing back the response audio from a previous request. When the client sees the utterance, it should stop the playback and immediately get ready for receiving the responses for the current request. The barge-in handling requires the client to start streaming audio input as soon as it starts playing back the audio from the previous response. The playback is modeled into two phases: * No barge-in phase: which goes first and during which speech detection should not be carried out. * Barge-in phase: which follows the no barge-in phase and during which the API starts speech detection and may inform the client that an utterance has been detected. Note that no-speech event is not expected in this phase. The client provides this configuration in terms of the durations of those two phases. The durations are measured in terms of the audio length from the start of the input audio. No-speech event is a response with END_OF_UTTERANCE without any transcript following up.
*/
export interface Schema$GoogleCloudDialogflowCxV3BargeInConfig {
/**
* Duration that is not eligible for barge-in at the beginning of the input audio.
*/
noBargeInDuration?: string | null;
/**
* Total duration for the playback at the beginning of the input audio.
*/
totalDuration?: string | null;
}
/**
* Metadata returned for the TestCases.BatchRunTestCases long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3BatchRunTestCasesMetadata {
/**
* The test errors.
*/
errors?: Schema$GoogleCloudDialogflowCxV3TestError[];
}
/**
* The response message for TestCases.BatchRunTestCases.
*/
export interface Schema$GoogleCloudDialogflowCxV3BatchRunTestCasesResponse {
/**
* The test case results. The detailed conversation turns are empty in this response.
*/
results?: Schema$GoogleCloudDialogflowCxV3TestCaseResult[];
}
/**
* Hierarchical advanced settings for agent/flow/page/fulfillment/parameter. Settings exposed at lower level overrides the settings exposed at higher level. Overriding occurs at the sub-setting level. For example, the playback_interruption_settings at fulfillment level only overrides the playback_interruption_settings at the agent level, leaving other settings at the agent level unchanged. DTMF settings does not override each other. DTMF settings set at different levels define DTMF detections running in parallel. Hierarchy: Agent-\>Flow-\>Page-\>Fulfillment/Parameter.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettings {
/**
* If present, incoming audio is exported by Dialogflow to the configured Google Cloud Storage destination. Exposed at the following levels: - Agent level - Flow level
*/
audioExportGcsDestination?: Schema$GoogleCloudDialogflowCxV3beta1GcsDestination;
/**
* Settings for DTMF. Exposed at the following levels: - Agent level - Flow level - Page level - Parameter level.
*/
dtmfSettings?: Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettingsDtmfSettings;
/**
* Settings for logging. Settings for Dialogflow History, Contact Center messages, StackDriver logs, and speech logging. Exposed at the following levels: - Agent level.
*/
loggingSettings?: Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettingsLoggingSettings;
/**
* Settings for speech to text detection. Exposed at the following levels: - Agent level - Flow level - Page level - Parameter level
*/
speechSettings?: Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettingsSpeechSettings;
}
/**
* Define behaviors for DTMF (dual tone multi frequency).
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettingsDtmfSettings {
/**
* If true, incoming audio is processed for DTMF (dual tone multi frequency) events. For example, if the caller presses a button on their telephone keypad and DTMF processing is enabled, Dialogflow will detect the event (e.g. a "3" was pressed) in the incoming audio and pass the event to the bot to drive business logic (e.g. when 3 is pressed, return the account balance).
*/
enabled?: boolean | null;
/**
* Endpoint timeout setting for matching dtmf input to regex.
*/
endpointingTimeoutDuration?: string | null;
/**
* The digit that terminates a DTMF digit sequence.
*/
finishDigit?: string | null;
/**
* Interdigit timeout setting for matching dtmf input to regex.
*/
interdigitTimeoutDuration?: string | null;
/**
* Max length of DTMF digits.
*/
maxDigits?: number | null;
}
/**
* Define behaviors on logging.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettingsLoggingSettings {
/**
* Enables consent-based end-user input redaction, if true, a pre-defined session parameter `$session.params.conversation-redaction` will be used to determine if the utterance should be redacted.
*/
enableConsentBasedRedaction?: boolean | null;
/**
* Enables DF Interaction logging.
*/
enableInteractionLogging?: boolean | null;
/**
* Enables Google Cloud Logging.
*/
enableStackdriverLogging?: boolean | null;
}
/**
* Define behaviors of speech to text detection.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettingsSpeechSettings {
/**
* Sensitivity of the speech model that detects the end of speech. Scale from 0 to 100.
*/
endpointerSensitivity?: number | null;
/**
* Mapping from language to Speech-to-Text model. The mapped Speech-to-Text model will be selected for requests from its corresponding language. For more information, see [Speech models](https://cloud.google.com/dialogflow/cx/docs/concept/speech-models).
*/
models?: {
[key: string]: string;
} | null;
/**
* Timeout before detecting no speech.
*/
noSpeechTimeout?: string | null;
/**
* Use timeout based endpointing, interpreting endpointer sensitivity as seconds of timeout value.
*/
useTimeoutBasedEndpointing?: boolean | null;
}
/**
* Represents the natural speech audio to be processed.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1AudioInput {
/**
* The natural language speech audio to be processed. A single request can contain up to 2 minutes of speech audio data. The transcribed text cannot contain more than 256 bytes. For non-streaming audio detect intent, both `config` and `audio` must be provided. For streaming audio detect intent, `config` must be provided in the first request and `audio` must be provided in all following requests.
*/
audio?: string | null;
/**
* Required. Instructs the speech recognizer how to process the speech audio.
*/
config?: Schema$GoogleCloudDialogflowCxV3beta1InputAudioConfig;
}
/**
* Configuration of the barge-in behavior. Barge-in instructs the API to return a detected utterance at a proper time while the client is playing back the response audio from a previous request. When the client sees the utterance, it should stop the playback and immediately get ready for receiving the responses for the current request. The barge-in handling requires the client to start streaming audio input as soon as it starts playing back the audio from the previous response. The playback is modeled into two phases: * No barge-in phase: which goes first and during which speech detection should not be carried out. * Barge-in phase: which follows the no barge-in phase and during which the API starts speech detection and may inform the client that an utterance has been detected. Note that no-speech event is not expected in this phase. The client provides this configuration in terms of the durations of those two phases. The durations are measured in terms of the audio length from the start of the input audio. No-speech event is a response with END_OF_UTTERANCE without any transcript following up.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1BargeInConfig {
/**
* Duration that is not eligible for barge-in at the beginning of the input audio.
*/
noBargeInDuration?: string | null;
/**
* Total duration for the playback at the beginning of the input audio.
*/
totalDuration?: string | null;
}
/**
* Metadata returned for the TestCases.BatchRunTestCases long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1BatchRunTestCasesMetadata {
/**
* The test errors.
*/
errors?: Schema$GoogleCloudDialogflowCxV3beta1TestError[];
}
/**
* The response message for TestCases.BatchRunTestCases.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1BatchRunTestCasesResponse {
/**
* The test case results. The detailed conversation turns are empty in this response.
*/
results?: Schema$GoogleCloudDialogflowCxV3beta1TestCaseResult[];
}
/**
* Represents a result from running a test case in an agent environment.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ContinuousTestResult {
/**
* The resource name for the continuous test result. Format: `projects//locations//agents//environments//continuousTestResults/`.
*/
name?: string | null;
/**
* The result of this continuous test run, i.e. whether all the tests in this continuous test run pass or not.
*/
result?: string | null;
/**
* Time when the continuous testing run starts.
*/
runTime?: string | null;
/**
* A list of individual test case results names in this continuous test run.
*/
testCaseResults?: string[] | null;
}
/**
* This message is used to hold all the Conversation Signals data, which will be converted to JSON and exported to BigQuery.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ConversationSignals {
/**
* Required. Turn signals for the current turn.
*/
turnSignals?: Schema$GoogleCloudDialogflowCxV3beta1TurnSignals;
}
/**
* One interaction between a human and virtual agent. The human provides some input and the virtual agent provides a response.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ConversationTurn {
/**
* The user input.
*/
userInput?: Schema$GoogleCloudDialogflowCxV3beta1ConversationTurnUserInput;
/**
* The virtual agent output.
*/
virtualAgentOutput?: Schema$GoogleCloudDialogflowCxV3beta1ConversationTurnVirtualAgentOutput;
}
/**
* The input from the human user.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ConversationTurnUserInput {
/**
* Whether sentiment analysis is enabled.
*/
enableSentimentAnalysis?: boolean | null;
/**
* Parameters that need to be injected into the conversation during intent detection.
*/
injectedParameters?: {
[key: string]: any;
} | null;
/**
* Supports text input, event input, dtmf input in the test case.
*/
input?: Schema$GoogleCloudDialogflowCxV3beta1QueryInput;
/**
* If webhooks should be allowed to trigger in response to the user utterance. Often if parameters are injected, webhooks should not be enabled.
*/
isWebhookEnabled?: boolean | null;
}
/**
* The output from the virtual agent.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ConversationTurnVirtualAgentOutput {
/**
* The Page on which the utterance was spoken. Only name and displayName will be set.
*/
currentPage?: Schema$GoogleCloudDialogflowCxV3beta1Page;
/**
* Required. Input only. The diagnostic info output for the turn. Required to calculate the testing coverage.
*/
diagnosticInfo?: {
[key: string]: any;
} | null;
/**
* Output only. If this is part of a result conversation turn, the list of differences between the original run and the replay for this output, if any.
*/
differences?: Schema$GoogleCloudDialogflowCxV3beta1TestRunDifference[];
/**
* The session parameters available to the bot at this point.
*/
sessionParameters?: {
[key: string]: any;
} | null;
/**
* Response error from the agent in the test result. If set, other output is empty.
*/
status?: Schema$GoogleRpcStatus;
/**
* The text responses from the agent for the turn.
*/
textResponses?: Schema$GoogleCloudDialogflowCxV3beta1ResponseMessageText[];
/**
* The Intent that triggered the response. Only name and displayName will be set.
*/
triggeredIntent?: Schema$GoogleCloudDialogflowCxV3beta1Intent;
}
/**
* Metadata associated with the long running operation for Versions.CreateVersion.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1CreateVersionOperationMetadata {
/**
* Name of the created version. Format: `projects//locations//agents//flows//versions/`.
*/
version?: string | null;
}
/**
* A data store connection. It represents a data store in Discovery Engine and the type of the contents it contains.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1DataStoreConnection {
/**
* The full name of the referenced data store. Formats: `projects/{project\}/locations/{location\}/collections/{collection\}/dataStores/{data_store\}` `projects/{project\}/locations/{location\}/dataStores/{data_store\}`
*/
dataStore?: string | null;
/**
* The type of the connected data store.
*/
dataStoreType?: string | null;
/**
* The document processing mode for the data store connection. Should only be set for PUBLIC_WEB and UNSTRUCTURED data stores. If not set it is considered as DOCUMENTS, as this is the legacy mode.
*/
documentProcessingMode?: string | null;
}
/**
* Metadata returned for the Environments.DeployFlow long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1DeployFlowMetadata {
/**
* Errors of running deployment tests.
*/
testErrors?: Schema$GoogleCloudDialogflowCxV3beta1TestError[];
}
/**
* The response message for Environments.DeployFlow.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1DeployFlowResponse {
/**
* The name of the flow version deployment. Format: `projects//locations//agents//environments//deployments/`.
*/
deployment?: string | null;
/**
* The updated environment where the flow is deployed.
*/
environment?: Schema$GoogleCloudDialogflowCxV3beta1Environment;
}
/**
* Represents the input for dtmf event.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1DtmfInput {
/**
* The dtmf digits.
*/
digits?: string | null;
/**
* The finish digit (if any).
*/
finishDigit?: string | null;
}
/**
* Represents an environment for an agent. You can create multiple versions of your agent and publish them to separate environments. When you edit an agent, you are editing the draft agent. At any point, you can save the draft agent as an agent version, which is an immutable snapshot of your agent. When you save the draft agent, it is published to the default environment. When you create agent versions, you can publish them to custom environments. You can create a variety of custom environments for testing, development, production, etc.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1Environment {
/**
* The human-readable description of the environment. The maximum length is 500 characters. If exceeded, the request is rejected.
*/
description?: string | null;
/**
* Required. The human-readable name of the environment (unique in an agent). Limit of 64 characters.
*/
displayName?: string | null;
/**
* The name of the environment. Format: `projects//locations//agents//environments/`.
*/
name?: string | null;
/**
* The test cases config for continuous tests of this environment.
*/
testCasesConfig?: Schema$GoogleCloudDialogflowCxV3beta1EnvironmentTestCasesConfig;
/**
* Output only. Update time of this environment.
*/
updateTime?: string | null;
/**
* A list of configurations for flow versions. You should include version configs for all flows that are reachable from `Start Flow` in the agent. Otherwise, an error will be returned.
*/
versionConfigs?: Schema$GoogleCloudDialogflowCxV3beta1EnvironmentVersionConfig[];
/**
* The webhook configuration for this environment.
*/
webhookConfig?: Schema$GoogleCloudDialogflowCxV3beta1EnvironmentWebhookConfig;
}
/**
* The configuration for continuous tests.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1EnvironmentTestCasesConfig {
/**
* Whether to run test cases in TestCasesConfig.test_cases periodically. Default false. If set to true, run once a day.
*/
enableContinuousRun?: boolean | null;
/**
* Whether to run test cases in TestCasesConfig.test_cases before deploying a flow version to the environment. Default false.
*/
enablePredeploymentRun?: boolean | null;
/**
* A list of test case names to run. They should be under the same agent. Format of each test case name: `projects//locations//agents//testCases/`
*/
testCases?: string[] | null;
}
/**
* Configuration for the version.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1EnvironmentVersionConfig {
/**
* Required. Flow, playbook and tool versions are supported. Format for flow version: projects//locations//agents//flows//versions/. Format for playbook version: projects//locations//agents//playbooks//versions/. Format for tool version: projects//locations//agents//tools//versions/.
*/
version?: string | null;
}
/**
* Configuration for webhooks.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1EnvironmentWebhookConfig {
/**
* The list of webhooks to override for the agent environment. The webhook must exist in the agent. You can override fields in `generic_web_service` and `service_directory`.
*/
webhookOverrides?: Schema$GoogleCloudDialogflowCxV3beta1Webhook[];
}
/**
* An event handler specifies an event that can be handled during a session. When the specified event happens, the following actions are taken in order: * If there is a `trigger_fulfillment` associated with the event, it will be called. * If there is a `target_page` associated with the event, the session will transition into the specified page. * If there is a `target_flow` associated with the event, the session will transition into the specified flow.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1EventHandler {
/**
* Required. The name of the event to handle.
*/
event?: string | null;
/**
* Output only. The unique identifier of this event handler.
*/
name?: string | null;
/**
* The target flow to transition to. Format: `projects//locations//agents//flows/`.
*/
targetFlow?: string | null;
/**
* The target page to transition to. Format: `projects//locations//agents//flows//pages/`.
*/
targetPage?: string | null;
/**
* The target playbook to transition to. Format: `projects//locations//agents//playbooks/`.
*/
targetPlaybook?: string | null;
/**
* The fulfillment to call when the event occurs. Handling webhook errors with a fulfillment enabled with webhook could cause infinite loop. It is invalid to specify such fulfillment for a handler handling webhooks.
*/
triggerFulfillment?: Schema$GoogleCloudDialogflowCxV3beta1Fulfillment;
}
/**
* Represents the event to trigger.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1EventInput {
/**
* Name of the event.
*/
event?: string | null;
}
/**
* The response message for Agents.ExportAgent.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportAgentResponse {
/**
* Uncompressed raw byte content for agent. This field is populated if none of `agent_uri` and `git_destination` are specified in ExportAgentRequest.
*/
agentContent?: string | null;
/**
* The URI to a file containing the exported agent. This field is populated if `agent_uri` is specified in ExportAgentRequest.
*/
agentUri?: string | null;
/**
* Commit SHA of the git push. This field is populated if `git_destination` is specified in ExportAgentRequest.
*/
commitSha?: string | null;
}
/**
* Metadata returned for the EntityTypes.ExportEntityTypes long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportEntityTypesMetadata {
}
/**
* The response message for EntityTypes.ExportEntityTypes.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportEntityTypesResponse {
/**
* Uncompressed byte content for entity types. This field is populated only if `entity_types_content_inline` is set to true in ExportEntityTypesRequest.
*/
entityTypesContent?: Schema$GoogleCloudDialogflowCxV3beta1InlineDestination;
/**
* The URI to a file containing the exported entity types. This field is populated only if `entity_types_uri` is specified in ExportEntityTypesRequest.
*/
entityTypesUri?: string | null;
}
/**
* The response message for Flows.ExportFlow.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportFlowResponse {
/**
* Uncompressed raw byte content for flow.
*/
flowContent?: string | null;
/**
* The URI to a file containing the exported flow. This field is populated only if `flow_uri` is specified in ExportFlowRequest.
*/
flowUri?: string | null;
}
/**
* Metadata returned for the Intents.ExportIntents long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportIntentsMetadata {
}
/**
* The response message for Intents.ExportIntents.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportIntentsResponse {
/**
* Uncompressed byte content for intents. This field is populated only if `intents_content_inline` is set to true in ExportIntentsRequest.
*/
intentsContent?: Schema$GoogleCloudDialogflowCxV3beta1InlineDestination;
/**
* The URI to a file containing the exported intents. This field is populated only if `intents_uri` is specified in ExportIntentsRequest.
*/
intentsUri?: string | null;
}
/**
* Metadata returned for the TestCases.ExportTestCases long running operation. This message currently has no fields.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportTestCasesMetadata {
}
/**
* The response message for TestCases.ExportTestCases.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ExportTestCasesResponse {
/**
* Uncompressed raw byte content for test cases.
*/
content?: string | null;
/**
* The URI to a file containing the exported test cases. This field is populated only if `gcs_uri` is specified in ExportTestCasesRequest.
*/
gcsUri?: string | null;
}
/**
* A form is a data model that groups related parameters that can be collected from the user. The process in which the agent prompts the user and collects parameter values from the user is called form filling. A form can be added to a page. When form filling is done, the filled parameters will be written to the session.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1Form {
/**
* Parameters to collect from the user.
*/
parameters?: Schema$GoogleCloudDialogflowCxV3beta1FormParameter[];
}
/**
* Represents a form parameter.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1FormParameter {
/**
* Hierarchical advanced settings for this parameter. The settings exposed at the lower level overrides the settings exposed at the higher level.
*/
advancedSettings?: Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettings;
/**
* The default value of an optional parameter. If the parameter is required, the default value will be ignored.
*/
defaultValue?: any | null;
/**
* Required. The human-readable name of the parameter, unique within the form.
*/
displayName?: string | null;
/**
* Required. The entity type of the parameter. Format: `projects/-/locations/-/agents/-/entityTypes/` for system entity types (for example, `projects/-/locations/-/agents/-/entityTypes/sys.date`), or `projects//locations//agents//entityTypes/` for developer entity types.
*/
entityType?: string | null;
/**
* Required. Defines fill behavior for the parameter.
*/
fillBehavior?: Schema$GoogleCloudDialogflowCxV3beta1FormParameterFillBehavior;
/**
* Indicates whether the parameter represents a list of values.
*/
isList?: boolean | null;
/**
* Indicates whether the parameter content should be redacted in log. If redaction is enabled, the parameter content will be replaced by parameter name during logging. Note: the parameter content is subject to redaction if either parameter level redaction or entity type level redaction is enabled.
*/
redact?: boolean | null;
/**
* Indicates whether the parameter is required. Optional parameters will not trigger prompts; however, they are filled if the user specifies them. Required parameters must be filled before form filling concludes.
*/
required?: boolean | null;
}
/**
* Configuration for how the filling of a parameter should be handled.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1FormParameterFillBehavior {
/**
* Required. The fulfillment to provide the initial prompt that the agent can present to the user in order to fill the parameter.
*/
initialPromptFulfillment?: Schema$GoogleCloudDialogflowCxV3beta1Fulfillment;
/**
* The handlers for parameter-level events, used to provide reprompt for the parameter or transition to a different page/flow. The supported events are: * `sys.no-match-`, where N can be from 1 to 6 * `sys.no-match-default` * `sys.no-input-`, where N can be from 1 to 6 * `sys.no-input-default` * `sys.invalid-parameter` `initial_prompt_fulfillment` provides the first prompt for the parameter. If the user's response does not fill the parameter, a no-match/no-input event will be triggered, and the fulfillment associated with the `sys.no-match-1`/`sys.no-input-1` handler (if defined) will be called to provide a prompt. The `sys.no-match-2`/`sys.no-input-2` handler (if defined) will respond to the next no-match/no-input event, and so on. A `sys.no-match-default` or `sys.no-input-default` handler will be used to handle all following no-match/no-input events after all numbered no-match/no-input handlers for the parameter are consumed. A `sys.invalid-parameter` handler can be defined to handle the case where the parameter values have been `invalidated` by webhook. For example, if the user's response fill the parameter, however the parameter was invalidated by webhook, the fulfillment associated with the `sys.invalid-parameter` handler (if defined) will be called to provide a prompt. If the event handler for the corresponding event can't be found on the parameter, `initial_prompt_fulfillment` will be re-prompted.
*/
repromptEventHandlers?: Schema$GoogleCloudDialogflowCxV3beta1EventHandler[];
}
/**
* A fulfillment can do one or more of the following actions at the same time: * Generate rich message responses. * Set parameter values. * Call the webhook. Fulfillments can be called at various stages in the Page or Form lifecycle. For example, when a DetectIntentRequest drives a session to enter a new page, the page's entry fulfillment can add a static response to the QueryResult in the returning DetectIntentResponse, call the webhook (for example, to load user data from a database), or both.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1Fulfillment {
/**
* Hierarchical advanced settings for this fulfillment. The settings exposed at the lower level overrides the settings exposed at the higher level.
*/
advancedSettings?: Schema$GoogleCloudDialogflowCxV3beta1AdvancedSettings;
/**
* Conditional cases for this fulfillment.
*/
conditionalCases?: Schema$GoogleCloudDialogflowCxV3beta1FulfillmentConditionalCases[];
/**
* If the flag is true, the agent will utilize LLM to generate a text response. If LLM generation fails, the defined responses in the fulfillment will be respected. This flag is only useful for fulfillments associated with no-match event handlers.
*/
enableGenerativeFallback?: boolean | null;
/**
* A list of Generators to be called during this fulfillment.
*/
generators?: Schema$GoogleCloudDialogflowCxV3beta1FulfillmentGeneratorSettings[];
/**
* The list of rich message responses to present to the user.
*/
messages?: Schema$GoogleCloudDialogflowCxV3beta1ResponseMessage[];
/**
* Whether Dialogflow should return currently queued fulfillment response messages in streaming APIs. If a webhook is specified, it happens before Dialogflow invokes webhook. Warning: 1) This flag only affects streaming API. Responses are still queued and returned once in non-streaming API. 2) The flag can be enabled in any fulfillment but only the first 3 partial responses will be returned. You may only want to apply it to fulfillments that have slow webhooks.
*/
returnPartialResponses?: boolean | null;
/**
* Set parameter values before executing the webhook.
*/
setParameterActions?: Schema$GoogleCloudDialogflowCxV3beta1FulfillmentSetParameterAction[];
/**
* The value of this field will be populated in the WebhookRequest `fulfillmentInfo.tag` field by Dialogflow when the associated webhook is called. The tag is typically used by the webhook service to identify which fulfillment is being called, but it could be used for other purposes. This field is required if `webhook` is specified.
*/
tag?: string | null;
/**
* The webhook to call. Format: `projects//locations//agents//webhooks/`.
*/
webhook?: string | null;
}
/**
* A list of cascading if-else conditions. Cases are mutually exclusive. The first one with a matching condition is selected, all the rest ignored.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1FulfillmentConditionalCases {
/**
* A list of cascading if-else conditions.
*/
cases?: Schema$GoogleCloudDialogflowCxV3beta1FulfillmentConditionalCasesCase[];
}
/**
* Each case has a Boolean condition. When it is evaluated to be True, the corresponding messages will be selected and evaluated recursively.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1FulfillmentConditionalCasesCase {
/**
* A list of case content.
*/
caseContent?: Schema$GoogleCloudDialogflowCxV3beta1FulfillmentConditionalCasesCaseCaseContent[];
/**
* The condition to activate and select this case. Empty means the condition is always true. The condition is evaluated against form parameters or session parameters. See the [conditions reference](https://cloud.google.com/dialogflow/cx/docs/reference/condition).
*/
condition?: string | null;
}
/**
* The list of messages or conditional cases to activate for this case.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1FulfillmentConditionalCasesCaseCaseContent {
/**
* Additional cases to be evaluated.
*/
additionalCases?: Schema$GoogleCloudDialogflowCxV3beta1FulfillmentConditionalCases;
/**
* Returned message.
*/
message?: Schema$GoogleCloudDialogflowCxV3beta1ResponseMessage;
}
/**
* Generator settings used by the LLM to generate a text response.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1FulfillmentGeneratorSettings {
/**
* Required. The generator to call. Format: `projects//locations//agents//generators/`.
*/
generator?: string | null;
/**
* Map from placeholder parameter in the Generator to corresponding session parameters. By default, Dialogflow uses the session parameter with the same name to fill in the generator template. e.g. If there is a placeholder parameter `city` in the Generator, Dialogflow default to fill in the `$city` with `$session.params.city`. However, you may choose to fill `$city` with `$session.params.desination-city`. - Map key: parameter ID - Map value: session parameter name
*/
inputParameters?: {
[key: string]: string;
} | null;
/**
* Required. Output parameter which should contain the generator response.
*/
outputParameter?: string | null;
}
/**
* Setting a parameter value.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1FulfillmentSetParameterAction {
/**
* Display name of the parameter.
*/
parameter?: string | null;
/**
* The new value of the parameter. A null value clears the parameter.
*/
value?: any | null;
}
/**
* Google Cloud Storage location for a Dialogflow operation that writes or exports objects (e.g. exported agent or transcripts) outside of Dialogflow.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1GcsDestination {
/**
* Required. The Google Cloud Storage URI for the exported objects. A URI is of the form: `gs://bucket/object-name-or-prefix` Whether a full object name, or just a prefix, its usage depends on the Dialogflow operation.
*/
uri?: string | null;
}
/**
* Metadata returned for the EntityTypes.ImportEntityTypes long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportEntityTypesMetadata {
}
/**
* The response message for EntityTypes.ImportEntityTypes.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportEntityTypesResponse {
/**
* Info which resources have conflicts when REPORT_CONFLICT merge_option is set in ImportEntityTypesRequest.
*/
conflictingResources?: Schema$GoogleCloudDialogflowCxV3beta1ImportEntityTypesResponseConflictingResources;
/**
* The unique identifier of the imported entity types. Format: `projects//locations//agents//entity_types/`.
*/
entityTypes?: string[] | null;
}
/**
* Conflicting resources detected during the import process. Only filled when REPORT_CONFLICT is set in the request and there are conflicts in the display names.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportEntityTypesResponseConflictingResources {
/**
* Display names of conflicting entities.
*/
entityDisplayNames?: string[] | null;
/**
* Display names of conflicting entity types.
*/
entityTypeDisplayNames?: string[] | null;
}
/**
* The response message for Flows.ImportFlow.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportFlowResponse {
/**
* The unique identifier of the new flow. Format: `projects//locations//agents//flows/`.
*/
flow?: string | null;
}
/**
* Metadata returned for the Intents.ImportIntents long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportIntentsMetadata {
}
/**
* The response message for Intents.ImportIntents.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportIntentsResponse {
/**
* Info which resources have conflicts when REPORT_CONFLICT merge_option is set in ImportIntentsRequest.
*/
conflictingResources?: Schema$GoogleCloudDialogflowCxV3beta1ImportIntentsResponseConflictingResources;
/**
* The unique identifier of the imported intents. Format: `projects//locations//agents//intents/`.
*/
intents?: string[] | null;
}
/**
* Conflicting resources detected during the import process. Only filled when REPORT_CONFLICT is set in the request and there are conflicts in the display names.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportIntentsResponseConflictingResources {
/**
* Display names of conflicting entities.
*/
entityDisplayNames?: string[] | null;
/**
* Display names of conflicting intents.
*/
intentDisplayNames?: string[] | null;
}
/**
* Metadata returned for the TestCases.ImportTestCases long running operation.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportTestCasesMetadata {
/**
* Errors for failed test cases.
*/
errors?: Schema$GoogleCloudDialogflowCxV3beta1TestCaseError[];
}
/**
* The response message for TestCases.ImportTestCases.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1ImportTestCasesResponse {
/**
* The unique identifiers of the new test cases. Format: `projects//locations//agents//testCases/`.
*/
names?: string[] | null;
}
/**
* Inline destination for a Dialogflow operation that writes or exports objects (e.g. intents) outside of Dialogflow.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1InlineDestination {
/**
* Output only. The uncompressed byte content for the objects. Only populated in responses.
*/
content?: string | null;
}
/**
* Instructs the speech recognizer on how to process the audio content.
*/
export interface Schema$GoogleCloudDialogflowCxV3beta1InputAudioConfig {
/**
* Required. Audio encoding of the audio content to process.
*/
audioEncoding?: string | null;
/**
* Configuration of barge-in behavior during the streaming of input audio.
*/
bargeInConfig?: Schema$GoogleCloudDialogflowCxV3beta1BargeInConfig;
/**
* Optional. If `true`, Dialogflow returns SpeechWordInfo in StreamingRecognitionResult with information about the recognized speech words, e.g. start and end time offsets. If false or unspecified, Speech doesn't return any word-level information.
*/
enableWordInfo?: boolean | null;
/**
* Optional. Which Speech model to select for the given request. For more information, see [Speech models](https://cloud.google.com/dialogflow/cx/docs/concept/speech-models).
*/
model?: string | null;
/**
* Optional. Which variant of the Speech model to use.
*/
modelVariant?: string | null;
/**
* If `true`, the request will opt out for STT conformer model migration. This field will be deprecated once force migration takes place in June 2024. Please refer to [Dialogflow CX Speech model migration](https://cloud.google.com/dialogflow/cx/docs/concept/speech-model-migration).
*/
optOutConformerModelMigration?: boolean | null;
/**
* Optional. A list of strings containing words and phrases that the speech recognizer should recognize with higher likelihood. See [the Cloud Speech documentation](https://cloud.google.com/speech-to-text/docs/basics#phrase-hints) for more details.
*/
phraseHints?: string[] | null;
/**
* Sample rate (in Hertz) of the audio content sent in the query