analyzeconversations.json

{
  "swagger": "2.0",
  "info": {
    "title": "Microsoft Cognitive Language Service - Analyze Conversations",
    "description": "The Language Service Conversations API is a suite of natural language processing (NLP) skills that you can use to analyze structured conversations (textual or spoken). The synchronous API in this suite accepts a request and mediates among multiple language projects, such as Language Understanding (LUIS) generally available, question answering, and conversational language understanding, and then calls the best candidate service to handle the request. Finally, it returns a response with the candidate service's response as a payload.\n\n In some cases, this API needs to forward requests and responses between the caller and an upstream service. The asynchronous APIs in this suite enable tasks like conversation summarization and detection of personally identifiable information (PII) in conversation.",
    "version": "2022-10-01-preview"
  },
  "securityDefinitions": {
    "AADToken": {
      "type": "oauth2",
      "authorizationUrl": "https://login.microsoftonline.com/common/oauth2/authorize",
      "flow": "implicit",
      "description": "These are the [Azure Active Directory OAuth2](https://docs.microsoft.com/azure/active-directory/develop/v1-overview) flows. When you pair them with [Azure role-based access control (RBAC)](https://docs.microsoft.com/azure/role-based-access-control/overview), you can use them to control access to Azure Maps REST APIs. You use RBAC to designate access to one or more Azure Maps resource accounts or subresources. You can grant any user, group, or service principal access via a built-in role or a custom role that consists of one or more permissions to Azure Maps REST APIs.\n\nTo implement scenarios, we recommend viewing [authentication concepts](https://aka.ms/amauth). In summary, this security definition provides a solution for modeling applications via objects that are capable of access control on specific APIs and scopes.\n\n#### Notes\n* This security definition requires the use of the x-ms-client-id header to indicate which Azure Maps resource the application is requesting access to. You can get this header from the [Azure Maps management API](https://aka.ms/amauthdetails).\n* \nThe authorization URL is specific to the Azure public cloud instance. Sovereign clouds have unique authorization URLs and Azure Active Directory configurations. \n* \nYou configure RBAC from the [Azure management plane](https://aka.ms/amrbac) via the Azure portal, PowerShell, the Azure CLI, Azure SDKs, or REST APIs.\n* \nUsage of the [Azure Maps Web SDK](https://aka.ms/amaadmc) allows for configuration-based setup of an application for multiple use cases.\n* Currently, Azure Active Directory [v1.0 or v2.0](https://docs.microsoft.com/azure/active-directory/develop/azure-ad-endpoint-comparison) supports work, school, and guest accounts but does not support personal accounts.",
      "scopes": {
        "https://cognitiveservices.azure.com/.default": "https://cognitiveservices.azure.com/.default"
      }
    },
    "apim_key": {
      "type": "apiKey",
      "description": "Subscription key for a language service resource.",
      "name": "Ocp-Apim-Subscription-Key",
      "in": "header"
    }
  },
  "security": [
    {
      "AADToken": [
        "https://cognitiveservices.azure.com/.default"
      ]
    },
    {
      "apim_key": []
    }
  ],
  "x-ms-parameterized-host": {
    "hostTemplate": "{Endpoint}/language",
    "useSchemePrefix": false,
    "parameters": [
      {
        "$ref": "common.json#/parameters/Endpoint"
      }
    ]
  },
  "paths": {
    "/:analyze-conversations": {
      "post": {
        "operationId": "ConversationAnalysis_AnalyzeConversation",
        "description": "Analyzes the input conversation utterance.",
        "parameters": [
          {
            "$ref": "common.json#/parameters/ApiVersionParameter"
          },
          {
            "description": "A single conversation task to execute.",
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/AnalyzeConversationTask"
            },
            "required": true
          }
        ],
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "responses": {
          "200": {
            "description": "Conversation analysis response.",
            "schema": {
              "$ref": "#/definitions/AnalyzeConversationTaskResult"
            }
          },
          "default": {
            "description": "Error response.",
            "schema": {
              "$ref": "common.json#/definitions/ErrorResponse"
            },
            "headers": {
              "x-ms-error-code": {
                "description": "Error code for the specific error that occurred.",
                "type": "string"
              }
            }
          }
        },
        "x-ms-examples": {
          "Conversation project result": {
            "$ref": "./examples/conversations/SuccessfulAnalyzeConversations.json"
          },
          "Arbitration result": {
            "$ref": "./examples/conversations/SuccessfulAnalyzeConversationsArbitration.json"
          },
          "Orchestrator direct target result": {
            "$ref": "./examples/conversations/SuccessfulAnalyzeConversationsArbitrationDirectTarget.json"
          }
        }
      }
    },
    "/analyze-conversations/jobs": {
      "post": {
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Submit a collection of conversations for analysis. Specify one or more unique tasks to be executed.",
        "operationId": "AnalyzeConversation_SubmitJob",
        "summary": "Submit analysis job for conversations",
        "parameters": [
          {
            "$ref": "common.json#/parameters/ApiVersionParameter"
          },
          {
            "description": "Collection of conversations to analyze and one or more tasks to execute.",
            "in": "body",
            "name": "body",
            "schema": {
              "$ref": "#/definitions/AnalyzeConversationJobsInput"
            },
            "required": true
          }
        ],
        "responses": {
          "202": {
            "description": "A successful call results in an Operation-Location header that's used to check the status of the analysis job.",
            "headers": {
              "Operation-Location": {
                "type": "string"
              }
            }
          },
          "default": {
            "description": "Error response.",
            "schema": {
              "$ref": "common.json#/definitions/ErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Successful Conversational PII Analysis Job Request": {
            "$ref": "./examples/conversations/SuccessfulConversationPIISubmit.json"
          },
          "Successful Conversation Summarization Analysis Job Request": {
            "$ref": "./examples/conversations/SuccessfulConversationSummarySubmit.json"
          },
          "Successful Conversation Summarization Task Submit": {
            "$ref": "./examples/conversations/SuccessfulConversationSummarizationTaskSubmit.json"
          },
          "Successful Conversation Sentiment Analysis Job Request": {
            "$ref": "./examples/conversations/SuccessfulConversationSentimentSubmit.json"
          }
        },
        "x-ms-long-running-operation": true
      }
    },
    "/analyze-conversations/jobs/{jobId}": {
      "get": {
        "produces": [
          "application/json"
        ],
        "description": "Get the status of an analysis job. A job can consist of one or more tasks. After all tasks succeed, the job transitions to the succeeded state and results are available for each task.",
        "operationId": "AnalyzeConversation_JobStatus",
        "summary": "Get analysis status and results",
        "parameters": [
          {
            "$ref": "common.json#/parameters/ApiVersionParameter"
          },
          {
            "$ref": "common.json#/parameters/JobId"
          },
          {
            "$ref": "common.json#/parameters/ShowStats"
          }
        ],
        "responses": {
          "200": {
            "description": "Analysis job status and metadata.",
            "schema": {
              "$ref": "#/definitions/AnalyzeConversationJobState"
            }
          },
          "default": {
            "description": "Error encountered.",
            "schema": {
              "$ref": "common.json#/definitions/ErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Successful Get Conversation PII Analysis Job Status Request": {
            "$ref": "./examples/conversations/SuccessfulConversationPIITaskStatusRequest.json"
          },
          "Successful Get Text Conversation Analysis Job Status Request": {
            "$ref": "./examples/conversations/SuccessfulConversationSummarizationTaskStatusRequest.json"
          },
          "Successful Get Conversation Sentiment Analysis Job Status Request": {
            "$ref": "./examples/conversations/SuccessfulConversationSentimentTaskStatusRequest.json"
          },
          "Successful Get Conversation Summarization Result": {
            "$ref": "./examples/conversations/SuccessfulConversationSummarizationTaskResult.json"
          }
        }
      }
    },
    "/analyze-conversations/jobs/{jobId}:cancel": {
      "post": {
        "produces": [
          "application/json"
        ],
        "description": "Cancel a long-running job for text analysis of conversations.",
        "operationId": "AnalyzeConversation_CancelJob",
        "summary": "Cancel a long-running Text Analysis conversations job",
        "parameters": [
          {
            "$ref": "common.json#/parameters/ApiVersionParameter"
          },
          {
            "$ref": "common.json#/parameters/JobId"
          }
        ],
        "responses": {
          "202": {
            "description": "The request to cancel a job has been received.",
            "headers": {
              "Operation-Location": {
                "type": "string"
              }
            }
          },
          "default": {
            "description": "Unexpected error.",
            "schema": {
              "$ref": "common.json#/definitions/ErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Successful Job Delete Request": {
            "$ref": "./examples/conversations/SuccessfulAnalyzeConversationsJobsCancelRequest.json"
          }
        },
        "x-ms-long-running-operation": true
      }
    }
  },
  "definitions": {
    "AnalyzeConversationTaskKind": {
      "type": "string",
      "description": "Enumeration of supported conversation tasks.",
      "enum": [
        "Conversation"
      ],
      "x-ms-enum": {
        "name": "AnalyzeConversationTaskKind",
        "modelAsString": true
      }
    },
    "AnalyzeConversationTaskResultsKind": {
      "type": "string",
      "description": "Enumeration of supported conversation task results.",
      "enum": [
        "ConversationResult"
      ],
      "x-ms-enum": {
        "name": "AnalyzeConversationTaskResultsKind",
        "modelAsString": true
      }
    },
    "AnalyzeConversationTask": {
      "type": "object",
      "description": "Base class of a conversation input task.",
      "discriminator": "kind",
      "required": [
        "kind"
      ],
      "properties": {
        "kind": {
          "$ref": "#/definitions/AnalyzeConversationTaskKind"
        }
      }
    },
    "AnalyzeConversationTaskResult": {
      "type": "object",
      "description": "Base class of a conversation task result.",
      "discriminator": "kind",
      "required": [
        "kind"
      ],
      "properties": {
        "kind": {
          "$ref": "#/definitions/AnalyzeConversationTaskResultsKind"
        }
      }
    },
    "ConversationalTask": {
      "type": "object",
      "description": "Input for a custom conversation task.",
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationTask"
        }
      ],
      "properties": {
        "analysisInput": {
          "$ref": "#/definitions/ConversationAnalysisOptions"
        },
        "parameters": {
          "$ref": "#/definitions/ConversationTaskParameters"
        }
      },
      "x-ms-discriminator-value": "Conversation",
      "required": [
        "analysisInput",
        "parameters"
      ]
    },
    "ConversationTaskParameters": {
      "type": "object",
      "description": "Input parameters necessary for a conversation task.",
      "properties": {
        "projectName": {
          "type": "string",
          "description": "Name of the project to use."
        },
        "deploymentName": {
          "type": "string",
          "description": "Name of the deployment to use."
        },
        "verbose": {
          "type": "boolean",
          "description": "If true, the service will return more detailed information in the response."
        },
        "isLoggingEnabled": {
          "type": "boolean",
          "description": "If true, the service will keep the query for further review."
        },
        "stringIndexType": {
          "$ref": "common.json#/definitions/StringIndexType"
        },
        "directTarget": {
          "type": "string",
          "description": "Name of a target project to forward the request to."
        },
        "targetProjectParameters": {
          "type": "object",
          "description": "Dictionary that represents the parameters for each target project.",
          "additionalProperties": {
            "$ref": "#/definitions/AnalysisParameters"
          }
        }
      },
      "required": [
        "projectName",
        "deploymentName"
      ]
    },
    "ConversationalTaskResult": {
      "description": "Results of a conversation task.",
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationTaskResult"
        }
      ],
      "type": "object",
      "properties": {
        "result": {
          "$ref": "#/definitions/AnalyzeConversationResult"
        }
      },
      "required": [
        "result"
      ],
      "x-ms-discriminator-value": "ConversationResult"
    },
    "ConversationItemBase": {
      "type": "object",
      "description": "Abstract base for a user input formatted conversation (for example, text or transcript).",
      "properties": {
        "id": {
          "description": "ID of a conversation item.",
          "type": "string"
        },
        "participantId": {
          "description": "Participant ID of a conversation item.",
          "type": "string"
        },
        "language": {
          "description": "Override language of a conversation item in BCP 47 language representation.",
          "type": "string"
        },
        "modality": {
          "$ref": "#/definitions/Modality"
        },
        "role": {
          "type": "string",
          "description": "Role of the participant.",
          "enum": [
            "agent",
            "customer",
            "generic"
          ],
          "x-ms-enum": {
            "name": "role",
            "modelAsString": true
          }
        }
      },
      "required": [
        "participantId",
        "id"
      ],
      "additionalProperties": true
    },
    "TextConversationItem": {
      "type": "object",
      "description": "Text modality of an input conversation.",
      "allOf": [
        {
          "$ref": "#/definitions/ConversationItemBase"
        }
      ],
      "properties": {
        "text": {
          "description": "Text input.",
          "type": "string"
        }
      },
      "required": [
        "text"
      ]
    },
    "ConversationAnalysisOptions": {
      "type": "object",
      "description": "ConversationItem input and its optional parameters.",
      "required": [
        "conversationItem"
      ],
      "properties": {
        "conversationItem": {
          "$ref": "#/definitions/ConversationItemBase"
        }
      }
    },
    "AnalysisParameters": {
      "type": "object",
      "description": "This is the parameter set of either the orchestration project itself or one of the target services.",
      "required": [
        "targetProjectKind"
      ],
      "discriminator": "targetProjectKind",
      "properties": {
        "targetProjectKind": {
          "type": "string",
          "description": "Type of a target service.",
          "enum": [
            "Luis",
            "Conversation",
            "QuestionAnswering",
            "NonLinked"
          ],
          "x-ms-enum": {
            "name": "targetProjectKind",
            "modelAsString": true
          }
        },
        "apiVersion": {
          "type": "string",
          "description": "API version to use in calling a specific target service."
        }
      }
    },
    "NoneLinkedTargetIntentResult": {
      "type": "object",
      "description": "Wrap-up of a non-linked intent response.",
      "x-ms-discriminator-value": "NonLinked",
      "allOf": [
        {
          "$ref": "#/definitions/TargetIntentResult"
        }
      ],
      "properties": {
        "result": {
          "$ref": "#/definitions/ConversationResult",
          "description": "Actual response from a conversation project."
        }
      }
    },
    "LuisParameters": {
      "description": "This is a set of request parameters for LUIS generally available projects.",
      "x-ms-discriminator-value": "Luis",
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/AnalysisParameters"
        }
      ],
      "properties": {
        "query": {
          "type": "string",
          "maxLength": 500,
          "description": "Utterance to predict."
        },
        "callingOptions": {
          "type": "object",
          "description": "This customizes how the service calls LUIS generally available projects.",
          "$ref": "#/definitions/LuisCallingOptions"
        }
      },
      "additionalProperties": true
    },
    "LuisCallingOptions": {
      "description": "This customizes how the service calls LUIS generally available projects.",
      "type": "object",
      "properties": {
        "verbose": {
          "description": "Enable a verbose response.",
          "type": "boolean"
        },
        "log": {
          "description": "Save the log to add in training utterances later.",
          "type": "boolean"
        },
        "show-all-intents": {
          "description": "Set to true to show all intents.",
          "type": "boolean"
        },
        "timezoneOffset": {
          "type": "number",
          "description": "Time zone offset for the location of the request."
        },
        "spellCheck": {
          "type": "boolean",
          "description": "Enable spell checking."
        },
        "bing-spell-check-subscription-key": {
          "description": "Subscription key to use for enabling the Bing spell checker.",
          "type": "string"
        }
      }
    },
    "ConversationParameters": {
      "type": "object",
      "description": "This is a set of request parameters for customized conversation projects.",
      "x-ms-discriminator-value": "Conversation",
      "allOf": [
        {
          "$ref": "#/definitions/AnalysisParameters"
        }
      ],
      "properties": {
        "callingOptions": {
          "type": "object",
          "$ref": "#/definitions/ConversationCallingOptions"
        }
      }
    },
    "ConversationCallingOptions": {
      "type": "object",
      "description": "Option to set to call a conversation project.",
      "properties": {
        "language": {
          "description": "Language of the query in BCP 47 language representation.",
          "type": "string"
        },
        "verbose": {
          "description": "If true, the service will return more detailed information.",
          "type": "boolean"
        },
        "isLoggingEnabled": {
          "description": "If true, the query will be saved for customers to further review in authoring, to improve the model quality.",
          "type": "boolean"
        }
      }
    },
    "QuestionAnsweringParameters": {
      "type": "object",
      "description": "This is a set of request parameters for question-answering knowledge bases.",
      "x-ms-discriminator-value": "QuestionAnswering",
      "allOf": [
        {
          "$ref": "#/definitions/AnalysisParameters"
        }
      ],
      "properties": {
        "callingOptions": {
          "description": "Options sent to a question-answering knowledge base.",
          "$ref": "common.json#/definitions/AnswersOptions"
        }
      }
    },
    "AnalyzeConversationResult": {
      "type": "object",
      "description": "Represents a conversation analysis response.",
      "required": [
        "query",
        "prediction"
      ],
      "properties": {
        "query": {
          "type": "string",
          "description": "Conversation utterance given by the caller."
        },
        "detectedLanguage": {
          "type": "string",
          "description": "System detected language for the query in BCP 47 language representation."
        },
        "prediction": {
          "description": "Prediction result of a conversation project.",
          "$ref": "#/definitions/BasePrediction"
        }
      }
    },
    "BasePrediction": {
      "type": "object",
      "description": "This is the base class of prediction.",
      "required": [
        "projectKind"
      ],
      "discriminator": "projectKind",
      "properties": {
        "projectKind": {
          "type": "string",
          "description": "Type of the project.",
          "enum": [
            "Conversation",
            "Orchestration"
          ],
          "x-ms-enum": {
            "name": "projectKind",
            "modelAsString": true
          }
        },
        "topIntent": {
          "type": "string",
          "description": "Intent with the highest score."
        }
      }
    },
    "OrchestrationPrediction": {
      "type": "object",
      "description": "This represents the prediction result of an orchestration project.",
      "x-ms-discriminator-value": "Orchestration",
      "required": [
        "intents"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/BasePrediction"
        }
      ],
      "properties": {
        "intents": {
          "description": "Dictionary that contains all intents. A key is an intent name, and a value is its confidence score and target type. The top intent's value also contains the actual response from the target project.",
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/TargetIntentResult"
          }
        }
      }
    },
    "TargetIntentResult": {
      "type": "object",
      "description": "This is the base class of an intent prediction.",
      "discriminator": "targetProjectKind",
      "required": [
        "confidenceScore",
        "targetProjectKind"
      ],
      "properties": {
        "targetProjectKind": {
          "type": "string",
          "description": "This discriminator property specifies the type of the target project that returns the response.",
          "enum": [
            "Luis",
            "Conversation",
            "QuestionAnswering",
            "NonLinked"
          ],
          "x-ms-enum": {
            "name": "targetProjectKind",
            "modelAsString": true
          }
        },
        "apiVersion": {
          "type": "string",
          "description": "API version that's used to call a target service."
        },
        "confidenceScore": {
          "type": "number",
          "format": "double",
          "x-ms-client-name": "confidence",
          "description": "Prediction score, which ranges from 0.0 to 1.0.",
          "minimum": 0,
          "maximum": 1
        }
      }
    },
    "ConversationTargetIntentResult": {
      "type": "object",
      "description": "Wrap-up of a conversation project response.",
      "x-ms-discriminator-value": "Conversation",
      "allOf": [
        {
          "$ref": "#/definitions/TargetIntentResult"
        }
      ],
      "properties": {
        "result": {
          "type": "object",
          "$ref": "#/definitions/ConversationResult",
          "description": "Actual response from a conversation project."
        }
      }
    },
    "ConversationResult": {
      "type": "object",
      "description": "Response that a conversation project returned.",
      "required": [
        "query"
      ],
      "properties": {
        "query": {
          "description": "The same query given in a request.",
          "type": "string"
        },
        "detectedLanguage": {
          "description": "Detected language from the query in BCP 47 language representation.",
          "type": "string"
        },
        "prediction": {
          "description": "Predicted result for the query.",
          "$ref": "#/definitions/ConversationPrediction"
        }
      }
    },
    "ConversationPrediction": {
      "type": "object",
      "description": "Represents the prediction section of a conversation project.",
      "x-ms-discriminator-value": "Conversation",
      "required": [
        "intents",
        "entities"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/BasePrediction"
        }
      ],
      "properties": {
        "intents": {
          "description": "Intent classification results.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConversationIntent"
          }
        },
        "entities": {
          "description": "Entity extraction results.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConversationEntity"
          }
        }
      }
    },
    "ConversationIntent": {
      "type": "object",
      "description": "Intent classification result of a conversation project.",
      "required": [
        "category",
        "confidenceScore"
      ],
      "properties": {
        "category": {
          "description": "Predicted class.",
          "type": "string"
        },
        "confidenceScore": {
          "format": "float",
          "x-ms-client-name": "confidence",
          "description": "Confidence score of the class, from 0.0 to 1.0.",
          "type": "number",
          "minimum": 0,
          "maximum": 1
        }
      }
    },
    "ConversationEntity": {
      "type": "object",
      "description": "Entity extraction result of a conversation project.",
      "required": [
        "category",
        "text",
        "offset",
        "length",
        "confidenceScore"
      ],
      "properties": {
        "category": {
          "description": "Entity category.",
          "type": "string"
        },
        "text": {
          "description": "Predicted entity text.",
          "type": "string"
        },
        "offset": {
          "format": "int32",
          "description": "Starting index of this entity in the query.",
          "type": "integer"
        },
        "length": {
          "format": "int32",
          "description": "Length of the text.",
          "type": "integer"
        },
        "confidenceScore": {
          "format": "float",
          "x-ms-client-name": "confidence",
          "description": "Entity confidence score.",
          "type": "number"
        },
        "resolutions": {
          "description": "Collection of objects for entity resolution.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/BaseResolution"
          }
        },
        "extraInformation": {
          "description": "Collection of objects for entity extra information.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/BaseExtraInformation"
          }
        }
      }
    },
    "BaseResolution": {
      "description": "Abstract base class for entity resolutions.",
      "type": "object",
      "discriminator": "resolutionKind",
      "properties": {
        "resolutionKind": {
          "description": "Kind of entity resolution object.",
          "type": "string",
          "enum": [
            "BooleanResolution",
            "DateTimeResolution",
            "NumberResolution",
            "OrdinalResolution",
            "SpeedResolution",
            "WeightResolution",
            "LengthResolution",
            "VolumeResolution",
            "AreaResolution",
            "AgeResolution",
            "InformationResolution",
            "TemperatureResolution",
            "CurrencyResolution",
            "NumericRangeResolution",
            "TemporalSpanResolution"
          ],
          "x-ms-enum": {
            "name": "ResolutionKind",
            "modelAsString": true
          }
        }
      },
      "required": [
        "resolutionKind"
      ]
    },
    "QuantityResolution": {
      "description": "Represents resolutions for quantities.",
      "type": "object",
      "properties": {
        "value": {
          "type": "number",
          "format": "double",
          "description": "Numeric value that the extracted text denotes."
        }
      },
      "required": [
        "value"
      ]
    },
    "AgeResolution": {
      "description": "Represents the model for age entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "AgeResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "Year",
            "Month",
            "Week",
            "Day"
          ],
          "x-ms-enum": {
            "name": "AgeUnit",
            "modelAsString": true
          },
          "description": "Age unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "VolumeResolution": {
      "description": "Represents the model for volume entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "VolumeResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "CubicMeter",
            "CubicCentimeter",
            "CubicMillimeter",
            "Hectoliter",
            "Decaliter",
            "Liter",
            "Centiliter",
            "Milliliter",
            "CubicYard",
            "CubicInch",
            "CubicFoot",
            "CubicMile",
            "FluidOunce",
            "Teaspoon",
            "Tablespoon",
            "Pint",
            "Quart",
            "Cup",
            "Gill",
            "Pinch",
            "FluidDram",
            "Barrel",
            "Minim",
            "Cord",
            "Peck",
            "Bushel",
            "Hogshead"
          ],
          "x-ms-enum": {
            "name": "VolumeUnit",
            "modelAsString": true
          },
          "description": "Volume unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "SpeedResolution": {
      "description": "Represents the model for speed entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "SpeedResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "MetersPerSecond",
            "KilometersPerHour",
            "KilometersPerMinute",
            "KilometersPerSecond",
            "MilesPerHour",
            "Knot",
            "FootPerSecond",
            "FootPerMinute",
            "YardsPerMinute",
            "YardsPerSecond",
            "MetersPerMillisecond",
            "CentimetersPerMillisecond",
            "KilometersPerMillisecond"
          ],
          "x-ms-enum": {
            "name": "SpeedUnit",
            "modelAsString": true
          },
          "description": "Speed unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "AreaResolution": {
      "description": "Represents the model for area entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "AreaResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "SquareKilometer",
            "SquareHectometer",
            "SquareDecameter",
            "SquareDecimeter",
            "SquareMeter",
            "SquareCentimeter",
            "SquareMillimeter",
            "SquareInch",
            "SquareFoot",
            "SquareMile",
            "SquareYard",
            "Acre"
          ],
          "x-ms-enum": {
            "name": "AreaUnit",
            "modelAsString": true
          },
          "description": "Area unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "LengthResolution": {
      "description": "Represents the model for length entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "LengthResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "Kilometer",
            "Hectometer",
            "Decameter",
            "Meter",
            "Decimeter",
            "Centimeter",
            "Millimeter",
            "Micrometer",
            "Nanometer",
            "Picometer",
            "Mile",
            "Yard",
            "Inch",
            "Foot",
            "LightYear",
            "Pt"
          ],
          "x-ms-enum": {
            "name": "LengthUnit",
            "modelAsString": true
          },
          "description": "Length unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "InformationResolution": {
      "description": "Represents the model for information (data) entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "InformationResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "Bit",
            "Kilobit",
            "Megabit",
            "Gigabit",
            "Terabit",
            "Petabit",
            "Byte",
            "Kilobyte",
            "Megabyte",
            "Gigabyte",
            "Terabyte",
            "Petabyte"
          ],
          "x-ms-enum": {
            "name": "InformationUnit",
            "modelAsString": true
          },
          "description": "Information (data) unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "TemperatureResolution": {
      "description": "Represents the model for temperature entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "TemperatureResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "Fahrenheit",
            "Kelvin",
            "Rankine",
            "Celsius"
          ],
          "x-ms-enum": {
            "name": "TemperatureUnit",
            "modelAsString": true
          },
          "description": "Temperature unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "WeightResolution": {
      "description": "Represents the model for weight entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "WeightResolution",
      "properties": {
        "unit": {
          "type": "string",
          "enum": [
            "Unspecified",
            "Kilogram",
            "Gram",
            "Milligram",
            "Gallon",
            "MetricTon",
            "Ton",
            "Pound",
            "Ounce",
            "Grain",
            "PennyWeight",
            "LongTonBritish",
            "ShortTonUS",
            "ShortHundredWeightUS",
            "Stone",
            "Dram"
          ],
          "x-ms-enum": {
            "name": "WeightUnit",
            "modelAsString": true
          },
          "description": "Weight unit of measurement."
        }
      },
      "required": [
        "unit"
      ]
    },
    "CurrencyResolution": {
      "description": "Represents the model for currency entity resolution.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        },
        {
          "$ref": "#/definitions/QuantityResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "CurrencyResolution",
      "properties": {
        "ISO4217": {
          "type": "string",
          "description": "Alphabetic code based on another ISO standard, ISO 3166, which lists the codes for country/region names. The first two letters of the ISO 4217 three-letter code are the same as the code for the country/region name. Where possible, the third letter of the ISO 4217 code corresponds to the first letter of the currency name."
        },
        "value": {
          "type": "number",
          "format": "double",
          "description": "Money amount captured in the extracted entity."
        },
        "unit": {
          "type": "string",
          "description": "Unit of the amount captured in the extracted entity."
        }
      },
      "required": [
        "value",
        "unit"
      ]
    },
    "BooleanResolution": {
      "description": "Resolution for Boolean expressions.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "BooleanResolution",
      "properties": {
        "value": {
          "type": "boolean"
        }
      },
      "required": [
        "value"
      ]
    },
    "DateTimeResolution": {
      "description": "Resolution for date/time entity instances.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "DateTimeResolution",
      "properties": {
        "timex": {
          "$ref": "#/definitions/TimeExpression"
        },
        "dateTimeSubKind": {
          "type": "string",
          "enum": [
            "Time",
            "Date",
            "DateTime",
            "Duration",
            "Set"
          ],
          "x-ms-enum": {
            "name": "DateTimeSubKind",
            "modelAsString": true
          },
          "description": "Date/time subkind."
        },
        "value": {
          "type": "string",
          "description": "Actual time that the extracted text denotes."
        },
        "modifier": {
          "$ref": "#/definitions/TemporalModifier"
        }
      },
      "required": [
        "timex",
        "dateTimeSubKind",
        "value"
      ]
    },
    "NumberResolution": {
      "description": "Resolution for numeric entity instances.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "NumberResolution",
      "properties": {
        "numberKind": {
          "type": "string",
          "enum": [
            "Integer",
            "Decimal",
            "Power",
            "Fraction",
            "Percent",
            "Unspecified"
          ],
          "x-ms-enum": {
            "name": "NumberKind",
            "modelAsString": true
          },
          "description": "Type of the extracted number entity."
        },
        "value": {
          "type": "number",
          "format": "double",
          "description": "Numeric representation of what the extracted text denotes."
        }
      },
      "required": [
        "numberKind",
        "value"
      ]
    },
    "OrdinalResolution": {
      "description": "Resolution for ordinal number entity instances.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "OrdinalResolution",
      "properties": {
        "offset": {
          "type": "string",
          "description": "Offset with respect to the reference (for example, offset = -1 in \"show me the second to last\")."
        },
        "relativeTo": {
          "type": "string",
          "enum": [
            "Current",
            "End",
            "Start"
          ],
          "x-ms-enum": {
            "name": "RelativeTo",
            "modelAsString": true
          },
          "description": "Reference point that the ordinal number denotes."
        },
        "value": {
          "type": "string",
          "description": "Simple arithmetic expression that the ordinal number denotes."
        }
      },
      "required": [
        "offset",
        "relativeTo",
        "value"
      ]
    },
    "TemporalSpanResolution": {
      "description": "Represents the resolution of a date and/or time span.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "TemporalSpanResolution",
      "properties": {
        "begin": {
          "$ref": "#/definitions/TimeExpression"
        },
        "end": {
          "$ref": "#/definitions/TimeExpression"
        },
        "duration": {
          "type": "string",
          "description": "Duration value whose formatting is based on ISO 8601 (https://en.wikipedia.org/wiki/ISO_8601#Durations)."
        },
        "modifier": {
          "$ref": "#/definitions/TemporalModifier"
        },
        "timex": {
          "type": "string",
          "description": "Triplet that contains the beginning, the end, and the duration, all stated as ISO 8601 formatted strings."
        }
      }
    },
    "NumericRangeResolution": {
      "description": "Represents the resolution of numeric intervals.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseResolution"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "NumericRangeResolution",
      "properties": {
        "rangeKind": {
          "type": "string",
          "enum": [
            "Number",
            "Speed",
            "Weight",
            "Length",
            "Volume",
            "Area",
            "Age",
            "Information",
            "Temperature",
            "Currency"
          ],
          "x-ms-enum": {
            "name": "RangeKind",
            "modelAsString": true
          },
          "description": "Kind of range that the resolution object represents."
        },
        "minimum": {
          "type": "number",
          "format": "double",
          "description": "Beginning value of the interval."
        },
        "maximum": {
          "type": "number",
          "format": "double",
          "description": "Ending value of the interval."
        }
      },
      "required": [
        "rangeKind",
        "minimum",
        "maximum"
      ]
    },
    "TemporalModifier": {
      "type": "string",
      "description": "Modifier of a date/time instance.",
      "enum": [
        "AfterApprox",
        "Before",
        "BeforeStart",
        "Approx",
        "ReferenceUndefined",
        "SinceEnd",
        "AfterMid",
        "Start",
        "After",
        "BeforeEnd",
        "Until",
        "End",
        "Less",
        "Since",
        "AfterStart",
        "BeforeApprox",
        "Mid",
        "More"
      ],
      "x-ms-enum": {
        "name": "TemporalModifier",
        "modelAsString": true
      }
    },
    "TimeExpression": {
      "type": "string",
      "description": "Extended ISO 8601 date/time representation, as described in https://github.com/Microsoft/Recognizers-Text/blob/master/Patterns/English/English-DateTime.yaml."
    },
    "BaseExtraInformation": {
      "description": "Abstract base object for entity extra information.",
      "type": "object",
      "discriminator": "extraInformationKind",
      "properties": {
        "extraInformationKind": {
          "description": "Kind of extra information object.",
          "type": "string",
          "enum": [
            "EntitySubtype",
            "ListKey",
            "RegexKey"
          ],
          "x-ms-enum": {
            "name": "ExtraInformationKind",
            "modelAsString": true
          }
        }
      },
      "required": [
        "extraInformationKind"
      ]
    },
    "EntitySubtype": {
      "description": "Concrete entity subtype model of extra information.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseExtraInformation"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "EntitySubtype",
      "properties": {
        "value": {
          "type": "string",
          "description": "Subtype of an extracted entity type."
        }
      }
    },
    "ListKey": {
      "description": "Kind of extra data for a list key.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseExtraInformation"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "ListKey",
      "properties": {
        "key": {
          "type": "string",
          "description": "Canonical form of the extracted entity."
        }
      }
    },
    "RegexKey": {
      "description": "Kind of extra data for a regex key.",
      "allOf": [
        {
          "$ref": "#/definitions/BaseExtraInformation"
        }
      ],
      "type": "object",
      "x-ms-discriminator-value": "RegexKey",
      "properties": {
        "key": {
          "type": "string",
          "description": "Key of the regex pattern that's used in extracting the entity."
        },
        "regexPattern": {
          "type": "string",
          "description": ".NET regex pattern that's used in extracting the entity. For more information about .NET regular expressions, go to https://docs.microsoft.com/dotnet/standard/base-types/regular-expressions."
        }
      }
    },
    "LuisTargetIntentResult": {
      "type": "object",
      "description": "Wrap-up of the LUIS generally available response.",
      "x-ms-discriminator-value": "Luis",
      "allOf": [
        {
          "$ref": "#/definitions/TargetIntentResult"
        }
      ],
      "properties": {
        "result": {
          "type": "object",
          "description": "Actual response from a LUIS generally available application."
        }
      }
    },
    "QuestionAnsweringTargetIntentResult": {
      "type": "object",
      "description": "Wrap-up of the question-answering knowledge base response.",
      "x-ms-discriminator-value": "QuestionAnswering",
      "allOf": [
        {
          "$ref": "#/definitions/TargetIntentResult"
        }
      ],
      "properties": {
        "result": {
          "description": "Generated answer by a question-answering knowledge base.",
          "$ref": "common.json#/definitions/AnswersResult"
        }
      }
    },
    "AnalyzeConversationJobsInput": {
      "type": "object",
      "properties": {
        "displayName": {
          "description": "Display name for the analysis job.",
          "type": "string"
        },
        "analysisInput": {
          "$ref": "#/definitions/MultiLanguageConversationAnalysisInput"
        },
        "tasks": {
          "description": "Set of tasks to execute on the input conversation.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/AnalyzeConversationLROTask"
          }
        }
      },
      "required": [
        "analysisInput",
        "tasks"
      ]
    },
    "AnalyzeConversationLROTask": {
      "type": "object",
      "description": "Base class for a long-running conversation input task.",
      "discriminator": "kind",
      "required": [
        "kind"
      ],
      "properties": {
        "kind": {
          "$ref": "#/definitions/AnalyzeConversationLROTaskKind"
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/TaskIdentifier"
        }
      ]
    },
    "AnalyzeConversationLROTaskKind": {
      "type": "string",
      "description": "Enumeration of supported analysis tasks on a collection of conversations.",
      "enum": [
        "ConversationalPIITask",
        "ConversationalSummarizationTask",
        "ConversationalSentimentTask"
      ],
      "x-ms-enum": {
        "name": "AnalyzeConversationLROTaskKind",
        "modelAsString": true
      }
    },
    "AnalyzeConversationResultsKind": {
      "type": "string",
      "description": "Enumeration of results for supported conversation analysis tasks.",
      "enum": [
        "ConversationalPIIResults",
        "ConversationalSummarizationResults",
        "ConversationalSentimentResults"
      ],
      "x-ms-enum": {
        "name": "AnalyzeConversationResultsKind",
        "modelAsString": true
      }
    },
    "AnalyzeConversationPIITask": {
      "type": "object",
      "description": "Task definition for a PII redaction in conversations.",
      "properties": {
        "parameters": {
          "$ref": "#/definitions/ConversationPIITaskParameters"
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationLROTask"
        }
      ],
      "x-ms-discriminator-value": "ConversationalPIITask"
    },
    "ConversationPIIItemResult": {
      "type": "object",
      "required": [
        "id",
        "redactedContent",
        "entities"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "redactedContent": {
          "type": "object",
          "$ref": "#/definitions/RedactedTranscriptContent"
        },
        "entities": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Entity"
          }
        }
      }
    },
    "MultiLanguageConversationAnalysisInput": {
      "type": "object",
      "required": [
        "conversations"
      ],
      "properties": {
        "conversations": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Conversation"
          }
        }
      }
    },
    "Conversation": {
      "type": "object",
      "description": "Complete ordered set of utterances (spoken or written) by one or more speakers to be used for analysis.",
      "discriminator": "modality",
      "required": [
        "id",
        "language",
        "modality"
      ],
      "properties": {
        "id": {
          "description": "Unique identifier for the conversation.",
          "type": "string"
        },
        "language": {
          "description": "Language of the conversation item in BCP-47 format.",
          "type": "string"
        },
        "modality": {
          "$ref": "#/definitions/Modality"
        },
        "domain": {
          "$ref": "#/definitions/ConversationDomain"
        }
      }
    },
    "Modality": {
      "type": "string",
      "description": "Enumeration of supported conversational modalities.",
      "enum": [
        "transcript",
        "text"
      ],
      "x-ms-enum": {
        "name": "InputModality",
        "modelAsString": true
      }
    },
    "ConversationDomain": {
      "type": "string",
      "description": "Enumeration of supported conversational domains.",
      "enum": [
        "finance",
        "healthcare",
        "generic"
      ],
      "x-ms-enum": {
        "name": "ConversationDomain",
        "modelAsString": true
      }
    },
    "TextConversation": {
      "type": "object",
      "x-ms-discriminator-value": "text",
      "required": [
        "conversationItems"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Conversation"
        }
      ],
      "properties": {
        "conversationItems": {
          "description": "Ordered list of text conversation items in the conversation.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/TextConversationItem"
          }
        }
      }
    },
    "TranscriptConversation": {
      "type": "object",
      "x-ms-discriminator-value": "transcript",
      "required": [
        "conversationItems"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Conversation"
        }
      ],
      "properties": {
        "conversationItems": {
          "description": "Ordered list of transcript conversation items in the conversation.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/TranscriptConversationItem"
          }
        }
      }
    },
    "TranscriptConversationItem": {
      "type": "object",
      "description": "Additional properties for supporting transcript conversation.",
      "required": [
        "text",
        "lexical",
        "itn",
        "maskedItn"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ConversationItemBase"
        }
      ],
      "properties": {
        "itn": {
          "type": "string",
          "description": "Inverse text normalization (ITN) representation of input. The inverse-text-normalized form is the recognized text from Microsoft's speech-to-text API, with phone numbers, numbers, abbreviations, and other transformations applied."
        },
        "maskedItn": {
          "type": "string",
          "description": "Inverse-text-normalized format with profanity masking applied."
        },
        "text": {
          "type": "string",
          "description": "Display form of the recognized text from the speech-to-text API, with punctuation and capitalization added."
        },
        "lexical": {
          "type": "string",
          "description": "Lexical form of the recognized text from the speech-to-text API, with the actual words recognized."
        },
        "wordLevelTimings": {
          "type": "array",
          "description": "List of word-level audio timing information.",
          "items": {
            "$ref": "#/definitions/WordLevelTiming"
          }
        },
        "conversationItemLevelTiming": {
          "description": "Audio timing at the conversation item level. This still can help with AI quality if word-level audio timings are not available.",
          "$ref": "#/definitions/ConversationItemLevelTiming"
        }
      }
    },
    "RedactedTranscriptContent": {
      "type": "object",
      "description": "Transcript content response that the service generates, with all necessary personally identifiable information redacted.",
      "properties": {
        "itn": {
          "type": "string",
          "description": "Redacted output for input in inverse-text-normalized format."
        },
        "maskedItn": {
          "type": "string",
          "description": "Redacted output for input in masked inverse-text-normalized format."
        },
        "text": {
          "type": "string",
          "description": "Redacted output for input in text (Microsoft's speech-to-text 'display') format."
        },
        "lexical": {
          "type": "string",
          "description": "Redacted output for input in lexical format."
        },
        "audioTimings": {
          "type": "array",
          "description": "List of redacted audio segments.",
          "items": {
            "$ref": "#/definitions/AudioTiming"
          }
        }
      }
    },
    "WordLevelTiming": {
      "type": "object",
      "description": "Word-level timing information that the speech-to-text API generates. The words in this object should have 1:1 correspondence with the lexical input to allow for audio redaction.",
      "properties": {
        "word": {
          "type": "string",
          "description": "Recognized word."
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/AudioTiming"
        }
      ]
    },
    "AudioTiming": {
      "type": "object",
      "description": "Audio timing information.",
      "properties": {
        "offset": {
          "description": "Offset from the start of speech audio, in ticks. 1 tick = 100 nanoseconds.",
          "type": "integer",
          "format": "int64"
        },
        "duration": {
          "description": "Duration of word articulation, in ticks. 1 tick = 100 nanoseconds.",
          "type": "integer",
          "format": "int64"
        }
      }
    },
    "Entity": {
      "type": "object",
      "required": [
        "text",
        "category",
        "offset",
        "length",
        "confidenceScore"
      ],
      "properties": {
        "text": {
          "type": "string",
          "description": "Entity text as it appears in the request."
        },
        "category": {
          "type": "string",
          "description": "Entity type."
        },
        "subcategory": {
          "type": "string",
          "description": "Entity subtype."
        },
        "offset": {
          "type": "integer",
          "format": "int32",
          "description": "Start position for the entity text. Use of different stringIndexType values can affect the offset that's returned."
        },
        "length": {
          "type": "integer",
          "format": "int32",
          "description": "Length for the entity text. Use of different stringIndexType values can affect the length that's returned."
        },
        "confidenceScore": {
          "type": "number",
          "format": "double",
          "description": "Confidence score between 0 and 1 for the extracted entity."
        }
      }
    },
    "AnalyzeConversationConversationPIIResult": {
      "type": "object",
      "description": "Result from the PII detection and redaction operation that's performed on a list of conversations.",
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationJobResult"
        }
      ],
      "properties": {
        "results": {
          "$ref": "#/definitions/ConversationPIIResults"
        }
      },
      "required": [
        "results"
      ],
      "x-ms-discriminator-value": "ConversationalPIIResults"
    },
    "ConversationPIIResults": {
      "type": "object",
      "description": "Result from the PII detection and redaction operation for each conversation.",
      "required": [
        "conversations"
      ],
      "properties": {
        "conversations": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConversationalPIIResultWithResultBase"
          }
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/PreBuiltResult"
        }
      ]
    },
    "ConversationalPIIResultWithResultBase": {
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/ConversationPIIResult"
        },
        {
          "$ref": "#/definitions/ConversationResultBase"
        }
      ]
    },
    "ConversationPIIResult": {
      "type": "object",
      "description": "Result from the PII detection and redaction operation for each conversation.",
      "required": [
        "conversationItems"
      ],
      "properties": {
        "conversationItems": {
          "description": "Enumeration of PII detection and redaction operation results for all the conversation items in a conversation.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConversationPIIItemResult"
          }
        }
      }
    },
    "ConversationPIITaskParameters": {
      "type": "object",
      "description": "Supported parameters for a conversational PII detection and redaction task.",
      "properties": {
        "piiCategories": {
          "$ref": "#/definitions/ConversationPIICategories"
        },
        "includeAudioRedaction": {
          "type": "boolean",
          "description": "Flag to indicate if audio redaction is requested. By default, audio redaction won't be performed.",
          "default": false
        },
        "redactionSource": {
          "type": "string",
          "description": "For transcript conversations, this parameter provides information about which content type (ITN, text, lexical, masked ITN) should be used for entity detection. The details of the detected entities - like the offset, the length, and the text itself - will correspond to the text type selected here.",
          "$ref": "#/definitions/TranscriptContentType"
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/PreBuiltTaskParameters"
        }
      ]
    },
    "ConversationPIICategories": {
      "description": "Describes the PII categories to return for detection. If it's not provided, default categories that vary with the language will be returned.",
      "items": {
        "type": "string",
        "x-ms-enum": {
          "name": "ConversationPIICategory",
          "modelAsString": true
        },
        "enum": [
          "Address",
          "CreditCardNumber",
          "Email",
          "Name",
          "NumericIdentifier",
          "PhoneNumber",
          "USSocialSecurityNumber",
          "Miscellaneous",
          "All",
          "Default"
        ]
      },
      "type": "array",
      "uniqueItems": true
    },
    "TranscriptContentType": {
      "type": "string",
      "description": "Enumeration of supported transcript content types.",
      "enum": [
        "lexical",
        "itn",
        "maskedItn",
        "text"
      ],
      "x-ms-enum": {
        "name": "TranscriptContentType",
        "modelAsString": true
      }
    },
    "AnalyzeConversationSummarizationTask": {
      "type": "object",
      "description": "Task definition for conversational summarization.",
      "properties": {
        "parameters": {
          "$ref": "#/definitions/ConversationSummarizationTaskParameters"
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationLROTask"
        }
      ],
      "x-ms-discriminator-value": "ConversationalSummarizationTask"
    },
    "ConversationSummarizationTaskParameters": {
      "type": "object",
      "description": "Supported parameters for a conversational summarization task.",
      "required": [
        "summaryAspects"
      ],
      "properties": {
        "summaryAspects": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "issue",
              "resolution",
              "chapterTitle",
              "narrative"
            ],
            "x-ms-enum": {
              "name": "SummaryAspect",
              "modelAsString": true,
              "values": [
                {
                  "value": "issue",
                  "description": "Summary of issues in transcripts of web chats and service calls between customer-service agents and customers."
                },
                {
                  "value": "resolution",
                  "description": "Summary of resolutions in transcripts of web chats and service calls between customer-service agents and customers."
                },
                {
                  "value": "chapterTitle",
                  "description": "Chapter title of any conversation. It's usually one phrase or several phrases naturally combined. Long conversations tend to have more chapters. You can find the chapter boundary from the summary context."
                },
                {
                  "value": "narrative",
                  "description": "Generic narrative summary of any conversation. It generally converts the conversational language into formal written language, compresses the text length, and keeps the salient information."
                }
              ]
            }
          }
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/PreBuiltTaskParameters"
        },
        {
          "$ref": "common.json#/definitions/AbstractiveSummarizationTaskParametersBase"
        }
      ]
    },
    "AnalyzeConversationSummarizationResult": {
      "type": "object",
      "description": "Result for the summarization task on the conversation.",
      "properties": {
        "results": {
          "$ref": "#/definitions/SummaryResult"
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationJobResult"
        }
      ],
      "required": [
        "results"
      ],
      "x-ms-discriminator-value": "ConversationalSummarizationResults"
    },
    "SummaryResult": {
      "type": "object",
      "required": [
        "conversations"
      ],
      "properties": {
        "conversations": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConversationsSummaryResult"
          }
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/PreBuiltResult"
        }
      ]
    },
    "ConversationsSummaryResult": {
      "type": "object",
      "required": [
        "summaries"
      ],
      "properties": {
        "summaries": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/SummaryResultItem"
          }
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/ConversationResultBase"
        }
      ]
    },
    "SummaryResultItem": {
      "type": "object",
      "properties": {
        "aspect": {
          "type": "string"
        },
        "text": {
          "type": "string"
        },
        "contexts": {
          "type": "array",
          "description": "Context list of the summary.",
          "items": {
            "$ref": "#/definitions/ItemizedSummaryContext"
          }
        }
      },
      "required": [
        "aspect",
        "text"
      ]
    },
    "AnalyzeConversationalSentimentTask": {
      "type": "object",
      "description": "Task definition for a sentiment analysis in conversations.",
      "properties": {
        "parameters": {
          "$ref": "#/definitions/ConversationalSentimentTaskParameters"
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationLROTask"
        }
      ],
      "x-ms-discriminator-value": "ConversationalSentimentTask"
    },
    "ConversationalSentimentTaskParameters": {
      "type": "object",
      "description": "Supported parameters for a conversational sentiment analysis task.",
      "properties": {
        "predictionSource": {
          "type": "string",
          "description": "For transcript conversations, this parameter provides information about which content type should be used for sentiment analysis. The details of the sentiment analysis - like the offset, the length, and the text itself - will correspond to the text type selected here.",
          "$ref": "#/definitions/TranscriptContentType"
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/PreBuiltTaskParameters"
        }
      ]
    },
    "AnalyzeConversationSentimentResult": {
      "type": "object",
      "description": "Result from the sentiment analysis operation performed on a list of conversations.",
      "allOf": [
        {
          "$ref": "#/definitions/AnalyzeConversationJobResult"
        }
      ],
      "properties": {
        "results": {
          "$ref": "#/definitions/ConversationSentimentResults"
        }
      },
      "required": [
        "results"
      ],
      "x-ms-discriminator-value": "ConversationalSentimentResults"
    },
    "ConversationSentimentResults": {
      "type": "object",
      "description": "Result from the sentiment analysis operation for each conversation.",
      "required": [
        "conversations"
      ],
      "properties": {
        "conversations": {
          "type": "array",
          "items": {
            "allOf": [
              {
                "$ref": "#/definitions/ConversationSentimentResult"
              },
              {
                "$ref": "#/definitions/ConversationResultBase"
              }
            ]
          }
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/PreBuiltResult"
        }
      ]
    },
    "ConversationSentimentResult": {
      "type": "object",
      "description": "Result from the sentiment analysis operation for each conversation item.",
      "required": [
        "conversationItems"
      ],
      "properties": {
        "conversationItems": {
          "description": "Enumeration of sentiment operation results for all the conversation items in a conversation.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConversationSentimentItemResult"
          }
        }
      }
    },
    "ConversationSentimentItemResult": {
      "type": "object",
      "required": [
        "id",
        "participantId",
        "sentiment",
        "confidenceScores"
      ],
      "properties": {
        "id": {
          "description": "Identifier for the conversation item.",
          "type": "string"
        },
        "participantId": {
          "description": "Identifier for the speaker.",
          "type": "string"
        },
        "sentiment": {
          "$ref": "common.json#/definitions/Sentiment"
        },
        "confidenceScores": {
          "type": "object",
          "$ref": "common.json#/definitions/SentimentConfidenceScores"
        }
      }
    },
    "AnalyzeConversationJobState": {
      "description": "Contains the status of the submitted job for analyzing a conversation, along with related statistics.",
      "allOf": [
        {
          "$ref": "common.json#/definitions/JobState"
        },
        {
          "$ref": "#/definitions/ConversationTasksState"
        },
        {
          "$ref": "#/definitions/AnalyzeConversationJobStatistics"
        }
      ]
    },
    "AnalyzeConversationJobStatistics": {
      "description": "Contains the statistics for the submitted job.",
      "properties": {
        "statistics": {
          "$ref": "#/definitions/ConversationRequestStatistics"
        }
      },
      "type": "object"
    },
    "ConversationTasksState": {
      "description": "Contains the state for the tasks that are being executed as part of the submitted job for analyzing a conversation.",
      "properties": {
        "tasks": {
          "properties": {
            "completed": {
              "description": "Count of tasks that finished successfully.",
              "type": "integer",
              "format": "int32"
            },
            "failed": {
              "description": "Count of tasks that failed.",
              "type": "integer",
              "format": "int32"
            },
            "inProgress": {
              "description": "Count of tasks that are currently in progress.",
              "type": "integer",
              "format": "int32"
            },
            "total": {
              "description": "Total count of tasks submitted as part of the job.",
              "type": "integer",
              "format": "int32"
            },
            "items": {
              "description": "List of results from tasks (if available).",
              "type": "array",
              "items": {
                "$ref": "#/definitions/AnalyzeConversationJobResult"
              }
            }
          },
          "required": [
            "total",
            "completed",
            "failed",
            "inProgress"
          ],
          "type": "object"
        }
      },
      "required": [
        "tasks"
      ],
      "type": "object"
    },
    "AnalyzeConversationJobResult": {
      "type": "object",
      "description": "Container for results of all tasks in the conversation job.",
      "discriminator": "kind",
      "properties": {
        "kind": {
          "$ref": "#/definitions/AnalyzeConversationResultsKind"
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/TaskState"
        },
        {
          "$ref": "common.json#/definitions/TaskIdentifier"
        }
      ],
      "required": [
        "kind"
      ]
    },
    "ConversationResultBase": {
      "type": "object",
      "description": "Shared attributes for all conversational task results.",
      "required": [
        "id",
        "warnings"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "Unique, non-empty conversation identifier."
        },
        "warnings": {
          "type": "array",
          "description": "Warnings encountered in processing the document.",
          "items": {
            "$ref": "common.json#/definitions/InputWarning"
          }
        },
        "statistics": {
          "$ref": "#/definitions/ConversationStatistics"
        }
      }
    },
    "ConversationStatistics": {
      "type": "object",
      "description": "If showStats=true was specified in the request, this field contains information about the conversation payload.",
      "required": [
        "transactionsCount"
      ],
      "properties": {
        "transactionsCount": {
          "type": "integer",
          "format": "int32",
          "description": "Number of text units for the request."
        }
      }
    },
    "ConversationRequestStatistics": {
      "type": "object",
      "description": "if showStats=true was specified in the request, this field contains information about the request payload.",
      "required": [
        "conversationsCount",
        "validConversationsCount",
        "erroneousConversationsCount"
      ],
      "properties": {
        "conversationsCount": {
          "type": "integer",
          "format": "int32",
          "description": "Number of conversations submitted in the request."
        },
        "validConversationsCount": {
          "type": "integer",
          "format": "int32",
          "description": "Number of conversation documents. This excludes documents that are empty, over the size limit, or in unsupported languages."
        },
        "erroneousConversationsCount": {
          "type": "integer",
          "format": "int32",
          "description": "Number of invalid documents. This includes documents that are empty, over the size limit, or in unsupported languages."
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/RequestStatistics"
        }
      ]
    },
    "ConversationItemLevelTiming": {
      "type": "object",
      "description": "Audio timing at the conversation item level.",
      "allOf": [
        {
          "$ref": "#/definitions/AudioTiming"
        }
      ]
    },
    "ItemizedSummaryContext": {
      "type": "object",
      "description": "Context of the summary with a conversation item ID.",
      "required": [
        "conversationItemId"
      ],
      "properties": {
        "conversationItemId": {
          "type": "string",
          "description": "Reference to the ID of ConversationItem."
        }
      },
      "allOf": [
        {
          "$ref": "common.json#/definitions/SummaryContext"
        }
      ]
    }
  },
  "parameters": {
    "ConversationAnalysisOptions": {
      "name": "ConversationAnalysisOptions",
      "in": "body",
      "required": true,
      "schema": {
        "$ref": "#/definitions/ConversationAnalysisOptions"
      },
      "description": "POST body of the request.",
      "x-ms-parameter-location": "method"
    }
  }
}