/// Configures which glossary should be used for a specific target language, /// and defines options for applying that glossary. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TranslateTextGlossaryConfig { /// Required. Specifies the glossary used for this translation. Use /// this format: projects/*/locations/*/glossaries/* #[prost(string, tag = "1")] pub glossary: ::prost::alloc::string::String, /// Optional. Indicates match is case-insensitive. /// Default value is false if missing. #[prost(bool, tag = "2")] pub ignore_case: bool, } /// The request message for synchronous translation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TranslateTextRequest { /// Required. The content of the input in string format. /// We recommend the total content be less than 30k codepoints. The max length /// of this field is 1024. /// Use BatchTranslateText for larger text. #[prost(string, repeated, tag = "1")] pub contents: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Optional. The format of the source text, for example, "text/html", /// "text/plain". If left blank, the MIME type defaults to "text/html". #[prost(string, tag = "3")] pub mime_type: ::prost::alloc::string::String, /// Optional. The BCP-47 language code of the input text if /// known, for example, "en-US" or "sr-Latn". Supported language codes are /// listed in Language Support. If the source language isn't specified, the API /// attempts to identify the source language automatically and returns the /// source language within the response. #[prost(string, tag = "4")] pub source_language_code: ::prost::alloc::string::String, /// Required. The BCP-47 language code to use for translation of the input /// text, set to one of the language codes listed in Language Support. #[prost(string, tag = "5")] pub target_language_code: ::prost::alloc::string::String, /// Required. Project or location to make a call. Must refer to a caller's /// project. /// /// Format: `projects/{project-number-or-id}` or /// `projects/{project-number-or-id}/locations/{location-id}`. /// /// For global calls, use `projects/{project-number-or-id}/locations/global` or /// `projects/{project-number-or-id}`. /// /// Non-global location is required for requests using AutoML models or /// custom glossaries. /// /// Models and glossaries must be within the same region (have same /// location-id), otherwise an INVALID_ARGUMENT (400) error is returned. #[prost(string, tag = "8")] pub parent: ::prost::alloc::string::String, /// Optional. The `model` type requested for this translation. /// /// The format depends on model type: /// /// - AutoML Translation models: /// `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}` /// /// - General (built-in) models: /// `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`, /// /// /// For global (non-regionalized) requests, use `location-id` `global`. /// For example, /// `projects/{project-number-or-id}/locations/global/models/general/nmt`. /// /// If not provided, the default Google model (NMT) will be used #[prost(string, tag = "6")] pub model: ::prost::alloc::string::String, /// Optional. Glossary to be applied. The glossary must be /// within the same region (have the same location-id) as the model, otherwise /// an INVALID_ARGUMENT (400) error is returned. #[prost(message, optional, tag = "7")] pub glossary_config: ::core::option::Option, /// Optional. The labels with user-defined metadata for the request. /// /// Label keys and values can be no longer than 63 characters /// (Unicode codepoints), can only contain lowercase letters, numeric /// characters, underscores and dashes. International characters are allowed. /// Label values are optional. Label keys must start with a letter. /// /// See for more information. #[prost(map = "string, string", tag = "10")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct TranslateTextResponse { /// Text translation responses with no glossary applied. /// This field has the same length as /// \[`contents`][google.cloud.translation.v3beta1.TranslateTextRequest.contents\]. #[prost(message, repeated, tag = "1")] pub translations: ::prost::alloc::vec::Vec, /// Text translation responses if a glossary is provided in the request. /// This can be the same as /// \[`translations`][google.cloud.translation.v3beta1.TranslateTextResponse.translations\] /// if no terms apply. This field has the same length as /// \[`contents`][google.cloud.translation.v3beta1.TranslateTextRequest.contents\]. #[prost(message, repeated, tag = "3")] pub glossary_translations: ::prost::alloc::vec::Vec, } /// A single translation response. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Translation { /// Text translated into the target language. /// If an error occurs during translation, this field might be excluded from /// the response. #[prost(string, tag = "1")] pub translated_text: ::prost::alloc::string::String, /// Only present when `model` is present in the request. /// `model` here is normalized to have project number. /// /// For example: /// If the `model` requested in TranslationTextRequest is /// `projects/{project-id}/locations/{location-id}/models/general/nmt` then /// `model` here would be normalized to /// `projects/{project-number}/locations/{location-id}/models/general/nmt`. #[prost(string, tag = "2")] pub model: ::prost::alloc::string::String, /// The BCP-47 language code of source text in the initial request, detected /// automatically, if no source language was passed within the initial /// request. If the source language was passed, auto-detection of the language /// does not occur and this field is empty. #[prost(string, tag = "4")] pub detected_language_code: ::prost::alloc::string::String, /// The `glossary_config` used for this translation. #[prost(message, optional, tag = "3")] pub glossary_config: ::core::option::Option, } /// The request message for language detection. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DetectLanguageRequest { /// Required. Project or location to make a call. Must refer to a caller's /// project. /// /// Format: `projects/{project-number-or-id}/locations/{location-id}` or /// `projects/{project-number-or-id}`. /// /// For global calls, use `projects/{project-number-or-id}/locations/global` or /// `projects/{project-number-or-id}`. /// /// Only models within the same region (has same location-id) can be used. /// Otherwise an INVALID_ARGUMENT (400) error is returned. #[prost(string, tag = "5")] pub parent: ::prost::alloc::string::String, /// Optional. The language detection model to be used. /// /// Format: /// `projects/{project-number-or-id}/locations/{location-id}/models/language-detection/{model-id}` /// /// Only one language detection model is currently supported: /// `projects/{project-number-or-id}/locations/{location-id}/models/language-detection/default`. /// /// If not specified, the default model is used. #[prost(string, tag = "4")] pub model: ::prost::alloc::string::String, /// Optional. The format of the source text, for example, "text/html", /// "text/plain". If left blank, the MIME type defaults to "text/html". #[prost(string, tag = "3")] pub mime_type: ::prost::alloc::string::String, /// Optional. The labels with user-defined metadata for the request. /// /// Label keys and values can be no longer than 63 characters /// (Unicode codepoints), can only contain lowercase letters, numeric /// characters, underscores and dashes. International characters are allowed. /// Label values are optional. Label keys must start with a letter. /// /// See for more information. #[prost(map = "string, string", tag = "6")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// Required. The source of the document from which to detect the language. #[prost(oneof = "detect_language_request::Source", tags = "1")] pub source: ::core::option::Option, } /// Nested message and enum types in `DetectLanguageRequest`. pub mod detect_language_request { /// Required. The source of the document from which to detect the language. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Source { /// The content of the input stored as a string. #[prost(string, tag = "1")] Content(::prost::alloc::string::String), } } /// The response message for language detection. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DetectedLanguage { /// The BCP-47 language code of source content in the request, detected /// automatically. #[prost(string, tag = "1")] pub language_code: ::prost::alloc::string::String, /// The confidence of the detection result for this language. #[prost(float, tag = "2")] pub confidence: f32, } /// The response message for language detection. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DetectLanguageResponse { /// A list of detected languages sorted by detection confidence in descending /// order. The most probable language first. #[prost(message, repeated, tag = "1")] pub languages: ::prost::alloc::vec::Vec, } /// The request message for discovering supported languages. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetSupportedLanguagesRequest { /// Required. Project or location to make a call. Must refer to a caller's /// project. /// /// Format: `projects/{project-number-or-id}` or /// `projects/{project-number-or-id}/locations/{location-id}`. /// /// For global calls, use `projects/{project-number-or-id}/locations/global` or /// `projects/{project-number-or-id}`. /// /// Non-global location is required for AutoML models. /// /// Only models within the same region (have same location-id) can be used, /// otherwise an INVALID_ARGUMENT (400) error is returned. #[prost(string, tag = "3")] pub parent: ::prost::alloc::string::String, /// Optional. The language to use to return localized, human readable names /// of supported languages. If missing, then display names are not returned /// in a response. #[prost(string, tag = "1")] pub display_language_code: ::prost::alloc::string::String, /// Optional. Get supported languages of this model. /// /// The format depends on model type: /// /// - AutoML Translation models: /// `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}` /// /// - General (built-in) models: /// `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`, /// /// /// Returns languages supported by the specified model. /// If missing, we get supported languages of Google general NMT model. #[prost(string, tag = "2")] pub model: ::prost::alloc::string::String, } /// The response message for discovering supported languages. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SupportedLanguages { /// A list of supported language responses. This list contains an entry /// for each language the Translation API supports. #[prost(message, repeated, tag = "1")] pub languages: ::prost::alloc::vec::Vec, } /// A single supported language response corresponds to information related /// to one supported language. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SupportedLanguage { /// Supported language code, generally consisting of its ISO 639-1 /// identifier, for example, 'en', 'ja'. In certain cases, BCP-47 codes /// including language and region identifiers are returned (for example, /// 'zh-TW' and 'zh-CN') #[prost(string, tag = "1")] pub language_code: ::prost::alloc::string::String, /// Human readable name of the language localized in the display language /// specified in the request. #[prost(string, tag = "2")] pub display_name: ::prost::alloc::string::String, /// Can be used as source language. #[prost(bool, tag = "3")] pub support_source: bool, /// Can be used as target language. #[prost(bool, tag = "4")] pub support_target: bool, } /// The Google Cloud Storage location for the input content. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GcsSource { /// Required. Source data URI. For example, `gs://my_bucket/my_object`. #[prost(string, tag = "1")] pub input_uri: ::prost::alloc::string::String, } /// Input configuration for BatchTranslateText request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InputConfig { /// Optional. Can be "text/plain" or "text/html". /// For `.tsv`, "text/html" is used if mime_type is missing. /// For `.html`, this field must be "text/html" or empty. /// For `.txt`, this field must be "text/plain" or empty. #[prost(string, tag = "1")] pub mime_type: ::prost::alloc::string::String, /// Required. Specify the input. #[prost(oneof = "input_config::Source", tags = "2")] pub source: ::core::option::Option, } /// Nested message and enum types in `InputConfig`. pub mod input_config { /// Required. Specify the input. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Source { /// Required. Google Cloud Storage location for the source input. /// This can be a single file (for example, /// `gs://translation-test/input.tsv`) or a wildcard (for example, /// `gs://translation-test/*`). If a file extension is `.tsv`, it can /// contain either one or two columns. The first column (optional) is the id /// of the text request. If the first column is missing, we use the row /// number (0-based) from the input file as the ID in the output file. The /// second column is the actual text to be /// translated. We recommend each row be <= 10K Unicode codepoints, /// otherwise an error might be returned. /// Note that the input tsv must be RFC 4180 compliant. /// /// You could use to check potential /// formatting errors in your tsv file. /// csvlint --delimiter='\t' your_input_file.tsv /// /// The other supported file extensions are `.txt` or `.html`, which is /// treated as a single large chunk of text. #[prost(message, tag = "2")] GcsSource(super::GcsSource), } } /// The Google Cloud Storage location for the output content. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GcsDestination { /// Required. There must be no files under 'output_uri_prefix'. /// 'output_uri_prefix' must end with "/" and start with "gs://", otherwise an /// INVALID_ARGUMENT (400) error is returned. #[prost(string, tag = "1")] pub output_uri_prefix: ::prost::alloc::string::String, } /// Output configuration for BatchTranslateText request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct OutputConfig { /// Required. The destination of output. #[prost(oneof = "output_config::Destination", tags = "1")] pub destination: ::core::option::Option, } /// Nested message and enum types in `OutputConfig`. pub mod output_config { /// Required. The destination of output. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Destination { /// Google Cloud Storage destination for output content. /// For every single input file (for example, gs://a/b/c.\[extension\]), we /// generate at most 2 * n output files. (n is the # of target_language_codes /// in the BatchTranslateTextRequest). /// /// Output files (tsv) generated are compliant with RFC 4180 except that /// record delimiters are '\n' instead of '\r\n'. We don't provide any way to /// change record delimiters. /// /// While the input files are being processed, we write/update an index file /// 'index.csv' under 'output_uri_prefix' (for example, /// gs://translation-test/index.csv) The index file is generated/updated as /// new files are being translated. The format is: /// /// input_file,target_language_code,translations_file,errors_file, /// glossary_translations_file,glossary_errors_file /// /// input_file is one file we matched using gcs_source.input_uri. /// target_language_code is provided in the request. /// translations_file contains the translations. (details provided below) /// errors_file contains the errors during processing of the file. (details /// below). Both translations_file and errors_file could be empty /// strings if we have no content to output. /// glossary_translations_file and glossary_errors_file are always empty /// strings if the input_file is tsv. They could also be empty if we have no /// content to output. /// /// Once a row is present in index.csv, the input/output matching never /// changes. Callers should also expect all the content in input_file are /// processed and ready to be consumed (that is, no partial output file is /// written). /// /// Since index.csv will be keeping updated during the process, please make /// sure there is no custom retention policy applied on the output bucket /// that may avoid file updating. /// () /// /// The format of translations_file (for target language code 'trg') is: /// gs://translation_test/a_b_c_'trg'_translations.\[extension\] /// /// If the input file extension is tsv, the output has the following /// columns: /// Column 1: ID of the request provided in the input, if it's not /// provided in the input, then the input row number is used (0-based). /// Column 2: source sentence. /// Column 3: translation without applying a glossary. Empty string if there /// is an error. /// Column 4 (only present if a glossary is provided in the request): /// translation after applying the glossary. Empty string if there is an /// error applying the glossary. Could be same string as column 3 if there is /// no glossary applied. /// /// If input file extension is a txt or html, the translation is directly /// written to the output file. If glossary is requested, a separate /// glossary_translations_file has format of /// gs://translation_test/a_b_c_'trg'_glossary_translations.\[extension\] /// /// The format of errors file (for target language code 'trg') is: /// gs://translation_test/a_b_c_'trg'_errors.\[extension\] /// /// If the input file extension is tsv, errors_file contains the following: /// Column 1: ID of the request provided in the input, if it's not /// provided in the input, then the input row number is used (0-based). /// Column 2: source sentence. /// Column 3: Error detail for the translation. Could be empty. /// Column 4 (only present if a glossary is provided in the request): /// Error when applying the glossary. /// /// If the input file extension is txt or html, glossary_error_file will be /// generated that contains error details. glossary_error_file has format of /// gs://translation_test/a_b_c_'trg'_glossary_errors.\[extension\] #[prost(message, tag = "1")] GcsDestination(super::GcsDestination), } } /// A document translation request input config. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DocumentInputConfig { /// Specifies the input document's mime_type. /// /// If not specified it will be determined using the file extension for /// gcs_source provided files. For a file provided through bytes content the /// mime_type must be provided. /// Currently supported mime types are: /// - application/pdf /// - application/vnd.openxmlformats-officedocument.wordprocessingml.document /// - application/vnd.openxmlformats-officedocument.presentationml.presentation /// - application/vnd.openxmlformats-officedocument.spreadsheetml.sheet #[prost(string, tag = "4")] pub mime_type: ::prost::alloc::string::String, /// Specifies the source for the document's content. /// The input file size should be <= 20MB for /// - application/vnd.openxmlformats-officedocument.wordprocessingml.document /// - application/vnd.openxmlformats-officedocument.presentationml.presentation /// - application/vnd.openxmlformats-officedocument.spreadsheetml.sheet /// The input file size should be <= 20MB and the maximum page limit is 20 for /// - application/pdf #[prost(oneof = "document_input_config::Source", tags = "1, 2")] pub source: ::core::option::Option, } /// Nested message and enum types in `DocumentInputConfig`. pub mod document_input_config { /// Specifies the source for the document's content. /// The input file size should be <= 20MB for /// - application/vnd.openxmlformats-officedocument.wordprocessingml.document /// - application/vnd.openxmlformats-officedocument.presentationml.presentation /// - application/vnd.openxmlformats-officedocument.spreadsheetml.sheet /// The input file size should be <= 20MB and the maximum page limit is 20 for /// - application/pdf #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Source { /// Document's content represented as a stream of bytes. #[prost(bytes, tag = "1")] Content(::prost::alloc::vec::Vec), /// Google Cloud Storage location. This must be a single file. /// For example: gs://example_bucket/example_file.pdf #[prost(message, tag = "2")] GcsSource(super::GcsSource), } } /// A document translation request output config. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DocumentOutputConfig { /// Optional. Specifies the translated document's mime_type. /// If not specified, the translated file's mime type will be the same as the /// input file's mime type. /// Currently only support the output mime type to be the same as input mime /// type. /// - application/pdf /// - application/vnd.openxmlformats-officedocument.wordprocessingml.document /// - application/vnd.openxmlformats-officedocument.presentationml.presentation /// - application/vnd.openxmlformats-officedocument.spreadsheetml.sheet #[prost(string, tag = "3")] pub mime_type: ::prost::alloc::string::String, /// A URI destination for the translated document. /// It is optional to provide a destination. If provided the results from /// TranslateDocument will be stored in the destination. /// Whether a destination is provided or not, the translated documents will be /// returned within TranslateDocumentResponse.document_translation and /// TranslateDocumentResponse.glossary_document_translation. #[prost(oneof = "document_output_config::Destination", tags = "1")] pub destination: ::core::option::Option, } /// Nested message and enum types in `DocumentOutputConfig`. pub mod document_output_config { /// A URI destination for the translated document. /// It is optional to provide a destination. If provided the results from /// TranslateDocument will be stored in the destination. /// Whether a destination is provided or not, the translated documents will be /// returned within TranslateDocumentResponse.document_translation and /// TranslateDocumentResponse.glossary_document_translation. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Destination { /// Optional. Google Cloud Storage destination for the translation output, /// e.g., `gs://my_bucket/my_directory/`. /// /// The destination directory provided does not have to be empty, but the /// bucket must exist. If a file with the same name as the output file /// already exists in the destination an error will be returned. /// /// For a DocumentInputConfig.contents provided document, the output file /// will have the name "output_\[trg]_translations.[ext\]", where /// - \[trg\] corresponds to the translated file's language code, /// - \[ext\] corresponds to the translated file's extension according to its /// mime type. /// /// /// For a DocumentInputConfig.gcs_uri provided document, the output file will /// have a name according to its URI. For example: an input file with URI: /// "gs://a/b/c.\[extension\]" stored in a gcs_destination bucket with name /// "my_bucket" will have an output URI: /// "gs://my_bucket/a_b_c_\[trg]_translations.[ext\]", where /// - \[trg\] corresponds to the translated file's language code, /// - \[ext\] corresponds to the translated file's extension according to its /// mime type. /// /// /// If the document was directly provided through the request, then the /// output document will have the format: /// "gs://my_bucket/translated_document_\[trg]_translations.[ext\], where /// - \[trg\] corresponds to the translated file's language code, /// - \[ext\] corresponds to the translated file's extension according to its /// mime type. /// /// If a glossary was provided, then the output URI for the glossary /// translation will be equal to the default output URI but have /// `glossary_translations` instead of `translations`. For the previous /// example, its glossary URI would be: /// "gs://my_bucket/a_b_c_\[trg]_glossary_translations.[ext\]". /// /// Thus the max number of output files will be 2 (Translated document, /// Glossary translated document). /// /// Callers should expect no partial outputs. If there is any error during /// document translation, no output will be stored in the Cloud Storage /// bucket. #[prost(message, tag = "1")] GcsDestination(super::GcsDestination), } } /// A document translation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TranslateDocumentRequest { /// Required. Location to make a regional call. /// /// Format: `projects/{project-number-or-id}/locations/{location-id}`. /// /// For global calls, use `projects/{project-number-or-id}/locations/global`. /// /// Non-global location is required for requests using AutoML models or custom /// glossaries. /// /// Models and glossaries must be within the same region (have the same /// location-id), otherwise an INVALID_ARGUMENT (400) error is returned. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The BCP-47 language code of the input document if known, for /// example, "en-US" or "sr-Latn". Supported language codes are listed in /// Language Support. If the source language isn't specified, the API attempts /// to identify the source language automatically and returns the source /// language within the response. Source language must be specified if the /// request contains a glossary or a custom model. #[prost(string, tag = "2")] pub source_language_code: ::prost::alloc::string::String, /// Required. The BCP-47 language code to use for translation of the input /// document, set to one of the language codes listed in Language Support. #[prost(string, tag = "3")] pub target_language_code: ::prost::alloc::string::String, /// Required. Input configurations. #[prost(message, optional, tag = "4")] pub document_input_config: ::core::option::Option, /// Optional. Output configurations. /// Defines if the output file should be stored within Cloud Storage as well /// as the desired output format. If not provided the translated file will /// only be returned through a byte-stream and its output mime type will be /// the same as the input file's mime type. #[prost(message, optional, tag = "5")] pub document_output_config: ::core::option::Option, /// Optional. The `model` type requested for this translation. /// /// The format depends on model type: /// /// - AutoML Translation models: /// `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}` /// /// - General (built-in) models: /// `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`, /// /// /// If not provided, the default Google model (NMT) will be used for /// translation. #[prost(string, tag = "6")] pub model: ::prost::alloc::string::String, /// Optional. Glossary to be applied. The glossary must be within the same /// region (have the same location-id) as the model, otherwise an /// INVALID_ARGUMENT (400) error is returned. #[prost(message, optional, tag = "7")] pub glossary_config: ::core::option::Option, /// Optional. The labels with user-defined metadata for the request. /// /// Label keys and values can be no longer than 63 characters (Unicode /// codepoints), can only contain lowercase letters, numeric characters, /// underscores and dashes. International characters are allowed. Label values /// are optional. Label keys must start with a letter. /// /// See for more /// information. #[prost(map = "string, string", tag = "8")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// A translated document message. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DocumentTranslation { /// The array of translated documents. It is expected to be size 1 for now. We /// may produce multiple translated documents in the future for other type of /// file formats. #[prost(bytes = "vec", repeated, tag = "1")] pub byte_stream_outputs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, /// The translated document's mime type. #[prost(string, tag = "2")] pub mime_type: ::prost::alloc::string::String, /// The detected language for the input document. /// If the user did not provide the source language for the input document, /// this field will have the language code automatically detected. If the /// source language was passed, auto-detection of the language does not occur /// and this field is empty. #[prost(string, tag = "3")] pub detected_language_code: ::prost::alloc::string::String, } /// A translated document response message. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TranslateDocumentResponse { /// Translated document. #[prost(message, optional, tag = "1")] pub document_translation: ::core::option::Option, /// The document's translation output if a glossary is provided in the request. /// This can be the same as \[TranslateDocumentResponse.document_translation\] /// if no glossary terms apply. #[prost(message, optional, tag = "2")] pub glossary_document_translation: ::core::option::Option, /// Only present when 'model' is present in the request. /// 'model' is normalized to have a project number. /// /// For example: /// If the 'model' field in TranslateDocumentRequest is: /// `projects/{project-id}/locations/{location-id}/models/general/nmt` then /// `model` here would be normalized to /// `projects/{project-number}/locations/{location-id}/models/general/nmt`. #[prost(string, tag = "3")] pub model: ::prost::alloc::string::String, /// The `glossary_config` used for this translation. #[prost(message, optional, tag = "4")] pub glossary_config: ::core::option::Option, } /// The batch translation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchTranslateTextRequest { /// Required. Location to make a call. Must refer to a caller's project. /// /// Format: `projects/{project-number-or-id}/locations/{location-id}`. /// /// The `global` location is not supported for batch translation. /// /// Only AutoML Translation models or glossaries within the same region (have /// the same location-id) can be used, otherwise an INVALID_ARGUMENT (400) /// error is returned. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. Source language code. #[prost(string, tag = "2")] pub source_language_code: ::prost::alloc::string::String, /// Required. Specify up to 10 language codes here. #[prost(string, repeated, tag = "3")] pub target_language_codes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Optional. The models to use for translation. Map's key is target language /// code. Map's value is model name. Value can be a built-in general model, /// or an AutoML Translation model. /// /// The value format depends on model type: /// /// - AutoML Translation models: /// `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}` /// /// - General (built-in) models: /// `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`, /// /// /// If the map is empty or a specific model is /// not requested for a language pair, then default google model (nmt) is used. #[prost(map = "string, string", tag = "4")] pub models: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// Required. Input configurations. /// The total number of files matched should be <= 100. /// The total content size should be <= 100M Unicode codepoints. /// The files must use UTF-8 encoding. #[prost(message, repeated, tag = "5")] pub input_configs: ::prost::alloc::vec::Vec, /// Required. Output configuration. /// If 2 input configs match to the same file (that is, same input path), /// we don't generate output for duplicate inputs. #[prost(message, optional, tag = "6")] pub output_config: ::core::option::Option, /// Optional. Glossaries to be applied for translation. /// It's keyed by target language code. #[prost(map = "string, message", tag = "7")] pub glossaries: ::std::collections::HashMap<::prost::alloc::string::String, TranslateTextGlossaryConfig>, /// Optional. The labels with user-defined metadata for the request. /// /// Label keys and values can be no longer than 63 characters /// (Unicode codepoints), can only contain lowercase letters, numeric /// characters, underscores and dashes. International characters are allowed. /// Label values are optional. Label keys must start with a letter. /// /// See for more information. #[prost(map = "string, string", tag = "9")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// State metadata for the batch translation operation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchTranslateMetadata { /// The state of the operation. #[prost(enumeration = "batch_translate_metadata::State", tag = "1")] pub state: i32, /// Number of successfully translated characters so far (Unicode codepoints). #[prost(int64, tag = "2")] pub translated_characters: i64, /// Number of characters that have failed to process so far (Unicode /// codepoints). #[prost(int64, tag = "3")] pub failed_characters: i64, /// Total number of characters (Unicode codepoints). /// This is the total number of codepoints from input files times the number of /// target languages and appears here shortly after the call is submitted. #[prost(int64, tag = "4")] pub total_characters: i64, /// Time when the operation was submitted. #[prost(message, optional, tag = "5")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, } /// Nested message and enum types in `BatchTranslateMetadata`. pub mod batch_translate_metadata { /// State of the job. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// Invalid. Unspecified = 0, /// Request is being processed. Running = 1, /// The batch is processed, and at least one item was successfully /// processed. Succeeded = 2, /// The batch is done and no item was successfully processed. Failed = 3, /// Request is in the process of being canceled after caller invoked /// longrunning.Operations.CancelOperation on the request id. Cancelling = 4, /// The batch is done after the user has called the /// longrunning.Operations.CancelOperation. Any records processed before the /// cancel command are output as specified in the request. Cancelled = 5, } } /// Stored in the /// \[google.longrunning.Operation.response][google.longrunning.Operation.response\] /// field returned by BatchTranslateText if at least one sentence is translated /// successfully. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchTranslateResponse { /// Total number of characters (Unicode codepoints). #[prost(int64, tag = "1")] pub total_characters: i64, /// Number of successfully translated characters (Unicode codepoints). #[prost(int64, tag = "2")] pub translated_characters: i64, /// Number of characters that have failed to process (Unicode codepoints). #[prost(int64, tag = "3")] pub failed_characters: i64, /// Time when the operation was submitted. #[prost(message, optional, tag = "4")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, /// The time when the operation is finished and /// \[google.longrunning.Operation.done][google.longrunning.Operation.done\] is /// set to true. #[prost(message, optional, tag = "5")] pub end_time: ::core::option::Option<::prost_types::Timestamp>, } /// Input configuration for glossaries. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GlossaryInputConfig { /// Required. Specify the input. #[prost(oneof = "glossary_input_config::Source", tags = "1")] pub source: ::core::option::Option, } /// Nested message and enum types in `GlossaryInputConfig`. pub mod glossary_input_config { /// Required. Specify the input. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Source { /// Required. Google Cloud Storage location of glossary data. /// File format is determined based on the filename extension. API returns /// \[google.rpc.Code.INVALID_ARGUMENT\] for unsupported URI-s and file /// formats. Wildcards are not allowed. This must be a single file in one of /// the following formats: /// /// For unidirectional glossaries: /// /// - TSV/CSV (`.tsv`/`.csv`): 2 column file, tab- or comma-separated. /// The first column is source text. The second column is target text. /// The file must not contain headers. That is, the first row is data, not /// column names. /// /// - TMX (`.tmx`): TMX file with parallel data defining source/target term /// pairs. /// /// For equivalent term sets glossaries: /// /// - CSV (`.csv`): Multi-column CSV file defining equivalent glossary terms /// in multiple languages. The format is defined for Google Translation /// Toolkit and documented in [Use a /// glossary](). #[prost(message, tag = "1")] GcsSource(super::GcsSource), } } /// Represents a glossary built from user provided data. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Glossary { /// Required. The resource name of the glossary. Glossary names have the form /// `projects/{project-number-or-id}/locations/{location-id}/glossaries/{glossary-id}`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Required. Provides examples to build the glossary from. /// Total glossary must not exceed 10M Unicode codepoints. #[prost(message, optional, tag = "5")] pub input_config: ::core::option::Option, /// Output only. The number of entries defined in the glossary. #[prost(int32, tag = "6")] pub entry_count: i32, /// Output only. When CreateGlossary was called. #[prost(message, optional, tag = "7")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. When the glossary creation was finished. #[prost(message, optional, tag = "8")] pub end_time: ::core::option::Option<::prost_types::Timestamp>, /// Languages supported by the glossary. #[prost(oneof = "glossary::Languages", tags = "3, 4")] pub languages: ::core::option::Option, } /// Nested message and enum types in `Glossary`. pub mod glossary { /// Used with unidirectional glossaries. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LanguageCodePair { /// Required. The BCP-47 language code of the input text, for example, /// "en-US". Expected to be an exact match for GlossaryTerm.language_code. #[prost(string, tag = "1")] pub source_language_code: ::prost::alloc::string::String, /// Required. The BCP-47 language code for translation output, for example, /// "zh-CN". Expected to be an exact match for GlossaryTerm.language_code. #[prost(string, tag = "2")] pub target_language_code: ::prost::alloc::string::String, } /// Used with equivalent term set glossaries. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LanguageCodesSet { /// The BCP-47 language code(s) for terms defined in the glossary. /// All entries are unique. The list contains at least two entries. /// Expected to be an exact match for GlossaryTerm.language_code. #[prost(string, repeated, tag = "1")] pub language_codes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Languages supported by the glossary. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Languages { /// Used with unidirectional glossaries. #[prost(message, tag = "3")] LanguagePair(LanguageCodePair), /// Used with equivalent term set glossaries. #[prost(message, tag = "4")] LanguageCodesSet(LanguageCodesSet), } } /// Request message for CreateGlossary. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateGlossaryRequest { /// Required. The project name. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The glossary to create. #[prost(message, optional, tag = "2")] pub glossary: ::core::option::Option, } /// Request message for GetGlossary. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetGlossaryRequest { /// Required. The name of the glossary to retrieve. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for DeleteGlossary. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteGlossaryRequest { /// Required. The name of the glossary to delete. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for ListGlossaries. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListGlossariesRequest { /// Required. The name of the project from which to list all of the glossaries. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. Requested page size. The server may return fewer glossaries than /// requested. If unspecified, the server picks an appropriate default. #[prost(int32, tag = "2")] pub page_size: i32, /// Optional. A token identifying a page of results the server should return. /// Typically, this is the value of \[ListGlossariesResponse.next_page_token\] /// returned from the previous call to `ListGlossaries` method. /// The first page is returned if `page_token`is empty or missing. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. Filter specifying constraints of a list operation. /// Specify the constraint by the format of "key=value", where key must be /// "src" or "tgt", and the value must be a valid language code. /// For multiple restrictions, concatenate them by "AND" (uppercase only), /// such as: "src=en-US AND tgt=zh-CN". Notice that the exact match is used /// here, which means using 'en-US' and 'en' can lead to different results, /// which depends on the language code you used when you create the glossary. /// For the unidirectional glossaries, the "src" and "tgt" add restrictions /// on the source and target language code separately. /// For the equivalent term set glossaries, the "src" and/or "tgt" add /// restrictions on the term set. /// For example: "src=en-US AND tgt=zh-CN" will only pick the unidirectional /// glossaries which exactly match the source language code as "en-US" and the /// target language code "zh-CN", but all equivalent term set glossaries which /// contain "en-US" and "zh-CN" in their language set will be picked. /// If missing, no filtering is performed. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, } /// Response message for ListGlossaries. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListGlossariesResponse { /// The list of glossaries for a project. #[prost(message, repeated, tag = "1")] pub glossaries: ::prost::alloc::vec::Vec, /// A token to retrieve a page of results. Pass this value in the /// \[ListGlossariesRequest.page_token\] field in the subsequent call to /// `ListGlossaries` method to retrieve the next page of results. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// Stored in the /// \[google.longrunning.Operation.metadata][google.longrunning.Operation.metadata\] /// field returned by CreateGlossary. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateGlossaryMetadata { /// The name of the glossary that is being created. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The current state of the glossary creation operation. #[prost(enumeration = "create_glossary_metadata::State", tag = "2")] pub state: i32, /// The time when the operation was submitted to the server. #[prost(message, optional, tag = "3")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, } /// Nested message and enum types in `CreateGlossaryMetadata`. pub mod create_glossary_metadata { /// Enumerates the possible states that the creation request can be in. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// Invalid. Unspecified = 0, /// Request is being processed. Running = 1, /// The glossary was successfully created. Succeeded = 2, /// Failed to create the glossary. Failed = 3, /// Request is in the process of being canceled after caller invoked /// longrunning.Operations.CancelOperation on the request id. Cancelling = 4, /// The glossary creation request was successfully canceled. Cancelled = 5, } } /// Stored in the /// \[google.longrunning.Operation.metadata][google.longrunning.Operation.metadata\] /// field returned by DeleteGlossary. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteGlossaryMetadata { /// The name of the glossary that is being deleted. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The current state of the glossary deletion operation. #[prost(enumeration = "delete_glossary_metadata::State", tag = "2")] pub state: i32, /// The time when the operation was submitted to the server. #[prost(message, optional, tag = "3")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, } /// Nested message and enum types in `DeleteGlossaryMetadata`. pub mod delete_glossary_metadata { /// Enumerates the possible states that the creation request can be in. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// Invalid. Unspecified = 0, /// Request is being processed. Running = 1, /// The glossary was successfully deleted. Succeeded = 2, /// Failed to delete the glossary. Failed = 3, /// Request is in the process of being canceled after caller invoked /// longrunning.Operations.CancelOperation on the request id. Cancelling = 4, /// The glossary deletion request was successfully canceled. Cancelled = 5, } } /// Stored in the /// \[google.longrunning.Operation.response][google.longrunning.Operation.response\] /// field returned by DeleteGlossary. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteGlossaryResponse { /// The name of the deleted glossary. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The time when the operation was submitted to the server. #[prost(message, optional, tag = "2")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, /// The time when the glossary deletion is finished and /// \[google.longrunning.Operation.done][google.longrunning.Operation.done\] is /// set to true. #[prost(message, optional, tag = "3")] pub end_time: ::core::option::Option<::prost_types::Timestamp>, } /// The BatchTranslateDocument request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchTranslateDocumentRequest { /// Required. Location to make a regional call. /// /// Format: `projects/{project-number-or-id}/locations/{location-id}`. /// /// The `global` location is not supported for batch translation. /// /// Only AutoML Translation models or glossaries within the same region (have /// the same location-id) can be used, otherwise an INVALID_ARGUMENT (400) /// error is returned. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The BCP-47 language code of the input document if known, for /// example, "en-US" or "sr-Latn". Supported language codes are listed in /// Language Support (). #[prost(string, tag = "2")] pub source_language_code: ::prost::alloc::string::String, /// Required. The BCP-47 language code to use for translation of the input /// document. Specify up to 10 language codes here. #[prost(string, repeated, tag = "3")] pub target_language_codes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Required. Input configurations. /// The total number of files matched should be <= 100. /// The total content size to translate should be <= 100M Unicode codepoints. /// The files must use UTF-8 encoding. #[prost(message, repeated, tag = "4")] pub input_configs: ::prost::alloc::vec::Vec, /// Required. Output configuration. /// If 2 input configs match to the same file (that is, same input path), /// we don't generate output for duplicate inputs. #[prost(message, optional, tag = "5")] pub output_config: ::core::option::Option, /// Optional. The models to use for translation. Map's key is target language /// code. Map's value is the model name. Value can be a built-in general model, /// or an AutoML Translation model. /// /// The value format depends on model type: /// /// - AutoML Translation models: /// `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}` /// /// - General (built-in) models: /// `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`, /// /// /// If the map is empty or a specific model is not requested for a language /// pair, then default google model (nmt) is used. #[prost(map = "string, string", tag = "6")] pub models: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// Optional. Glossaries to be applied. It's keyed by target language code. #[prost(map = "string, message", tag = "7")] pub glossaries: ::std::collections::HashMap<::prost::alloc::string::String, TranslateTextGlossaryConfig>, /// Optional. File format conversion map to be applied to all input files. /// Map's key is the original mime_type. Map's value is the target mime_type of /// translated documents. /// /// Supported file format conversion includes: /// - `application/pdf` to /// `application/vnd.openxmlformats-officedocument.wordprocessingml.document` /// /// If nothing specified, output files will be in the same format as the /// original file. #[prost(map = "string, string", tag = "8")] pub format_conversions: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// Input configuration for BatchTranslateDocument request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchDocumentInputConfig { /// Specify the input. #[prost(oneof = "batch_document_input_config::Source", tags = "1")] pub source: ::core::option::Option, } /// Nested message and enum types in `BatchDocumentInputConfig`. pub mod batch_document_input_config { /// Specify the input. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Source { /// Google Cloud Storage location for the source input. /// This can be a single file (for example, /// `gs://translation-test/input.docx`) or a wildcard (for example, /// `gs://translation-test/*`). /// /// File mime type is determined based on extension. Supported mime type /// includes: /// - `pdf`, application/pdf /// - `docx`, /// application/vnd.openxmlformats-officedocument.wordprocessingml.document /// - `pptx`, /// application/vnd.openxmlformats-officedocument.presentationml.presentation /// - `xlsx`, /// application/vnd.openxmlformats-officedocument.spreadsheetml.sheet /// /// The max file size to support for `.docx`, `.pptx` and `.xlsx` is 100MB. /// The max file size to support for `.pdf` is 1GB and the max page limit is /// 1000 pages. /// The max file size to support for all input documents is 1GB. #[prost(message, tag = "1")] GcsSource(super::GcsSource), } } /// Output configuration for BatchTranslateDocument request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchDocumentOutputConfig { /// The destination of output. The destination directory provided must exist /// and be empty. #[prost(oneof = "batch_document_output_config::Destination", tags = "1")] pub destination: ::core::option::Option, } /// Nested message and enum types in `BatchDocumentOutputConfig`. pub mod batch_document_output_config { /// The destination of output. The destination directory provided must exist /// and be empty. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Destination { /// Google Cloud Storage destination for output content. /// For every single input document (for example, gs://a/b/c.\[extension\]), we /// generate at most 2 * n output files. (n is the # of target_language_codes /// in the BatchTranslateDocumentRequest). /// /// While the input documents are being processed, we write/update an index /// file `index.csv` under `gcs_destination.output_uri_prefix` (for example, /// gs://translation_output/index.csv) The index file is generated/updated as /// new files are being translated. The format is: /// /// input_document,target_language_code,translation_output,error_output, /// glossary_translation_output,glossary_error_output /// /// `input_document` is one file we matched using gcs_source.input_uri. /// `target_language_code` is provided in the request. /// `translation_output` contains the translations. (details provided below) /// `error_output` contains the error message during processing of the file. /// Both translations_file and errors_file could be empty strings if we have /// no content to output. /// `glossary_translation_output` and `glossary_error_output` are the /// translated output/error when we apply glossaries. They could also be /// empty if we have no content to output. /// /// Once a row is present in index.csv, the input/output matching never /// changes. Callers should also expect all the content in input_file are /// processed and ready to be consumed (that is, no partial output file is /// written). /// /// Since index.csv will be keeping updated during the process, please make /// sure there is no custom retention policy applied on the output bucket /// that may avoid file updating. /// () /// /// The naming format of translation output files follows (for target /// language code \[trg\]): `translation_output`: /// gs://translation_output/a_b_c_\[trg]_translation.[extension\] /// `glossary_translation_output`: /// gs://translation_test/a_b_c_\[trg]_glossary_translation.[extension\] The /// output document will maintain the same file format as the input document. /// /// The naming format of error output files follows (for target language code /// \[trg\]): `error_output`: gs://translation_test/a_b_c_\[trg\]_errors.txt /// `glossary_error_output`: /// gs://translation_test/a_b_c_\[trg\]_glossary_translation.txt The error /// output is a txt file containing error details. #[prost(message, tag = "1")] GcsDestination(super::GcsDestination), } } /// Stored in the /// \[google.longrunning.Operation.response][google.longrunning.Operation.response\] /// field returned by BatchTranslateDocument if at least one document is /// translated successfully. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchTranslateDocumentResponse { /// Total number of pages to translate in all documents. Documents without /// clear page definition (such as XLSX) are not counted. #[prost(int64, tag = "1")] pub total_pages: i64, /// Number of successfully translated pages in all documents. Documents without /// clear page definition (such as XLSX) are not counted. #[prost(int64, tag = "2")] pub translated_pages: i64, /// Number of pages that failed to process in all documents. Documents without /// clear page definition (such as XLSX) are not counted. #[prost(int64, tag = "3")] pub failed_pages: i64, /// Number of billable pages in documents with clear page definition (such as /// PDF, DOCX, PPTX) #[prost(int64, tag = "4")] pub total_billable_pages: i64, /// Total number of characters (Unicode codepoints) in all documents. #[prost(int64, tag = "5")] pub total_characters: i64, /// Number of successfully translated characters (Unicode codepoints) in all /// documents. #[prost(int64, tag = "6")] pub translated_characters: i64, /// Number of characters that have failed to process (Unicode codepoints) in /// all documents. #[prost(int64, tag = "7")] pub failed_characters: i64, /// Number of billable characters (Unicode codepoints) in documents without /// clear page definition, such as XLSX. #[prost(int64, tag = "8")] pub total_billable_characters: i64, /// Time when the operation was submitted. #[prost(message, optional, tag = "9")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, /// The time when the operation is finished and /// \[google.longrunning.Operation.done][google.longrunning.Operation.done\] is /// set to true. #[prost(message, optional, tag = "10")] pub end_time: ::core::option::Option<::prost_types::Timestamp>, } /// State metadata for the batch translation operation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchTranslateDocumentMetadata { /// The state of the operation. #[prost(enumeration = "batch_translate_document_metadata::State", tag = "1")] pub state: i32, /// Total number of pages to translate in all documents so far. Documents /// without clear page definition (such as XLSX) are not counted. #[prost(int64, tag = "2")] pub total_pages: i64, /// Number of successfully translated pages in all documents so far. Documents /// without clear page definition (such as XLSX) are not counted. #[prost(int64, tag = "3")] pub translated_pages: i64, /// Number of pages that failed to process in all documents so far. Documents /// without clear page definition (such as XLSX) are not counted. #[prost(int64, tag = "4")] pub failed_pages: i64, /// Number of billable pages in documents with clear page definition (such as /// PDF, DOCX, PPTX) so far. #[prost(int64, tag = "5")] pub total_billable_pages: i64, /// Total number of characters (Unicode codepoints) in all documents so far. #[prost(int64, tag = "6")] pub total_characters: i64, /// Number of successfully translated characters (Unicode codepoints) in all /// documents so far. #[prost(int64, tag = "7")] pub translated_characters: i64, /// Number of characters that have failed to process (Unicode codepoints) in /// all documents so far. #[prost(int64, tag = "8")] pub failed_characters: i64, /// Number of billable characters (Unicode codepoints) in documents without /// clear page definition (such as XLSX) so far. #[prost(int64, tag = "9")] pub total_billable_characters: i64, /// Time when the operation was submitted. #[prost(message, optional, tag = "10")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, } /// Nested message and enum types in `BatchTranslateDocumentMetadata`. pub mod batch_translate_document_metadata { /// State of the job. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// Invalid. Unspecified = 0, /// Request is being processed. Running = 1, /// The batch is processed, and at least one item was successfully processed. Succeeded = 2, /// The batch is done and no item was successfully processed. Failed = 3, /// Request is in the process of being canceled after caller invoked /// longrunning.Operations.CancelOperation on the request id. Cancelling = 4, /// The batch is done after the user has called the /// longrunning.Operations.CancelOperation. Any records processed before the /// cancel command are output as specified in the request. Cancelled = 5, } } #[doc = r" Generated client implementations."] pub mod translation_service_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " Provides natural language translation operations."] #[derive(Debug, Clone)] pub struct TranslationServiceClient { inner: tonic::client::Grpc, } impl TranslationServiceClient where T: tonic::client::GrpcService, T::ResponseBody: Body + Send + 'static, T::Error: Into, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_interceptor( inner: T, interceptor: F, ) -> TranslationServiceClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { TranslationServiceClient::new(InterceptedService::new(inner, interceptor)) } #[doc = r" Compress requests with `gzip`."] #[doc = r""] #[doc = r" This requires the server to support it otherwise it might respond with an"] #[doc = r" error."] pub fn send_gzip(mut self) -> Self { self.inner = self.inner.send_gzip(); self } #[doc = r" Enable decompressing responses with `gzip`."] pub fn accept_gzip(mut self) -> Self { self.inner = self.inner.accept_gzip(); self } #[doc = " Translates input text and returns translated text."] pub async fn translate_text( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/TranslateText", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Detects the language of text within a request."] pub async fn detect_language( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/DetectLanguage", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Returns a list of supported languages for translation."] pub async fn get_supported_languages( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/GetSupportedLanguages", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Translates documents in synchronous mode."] pub async fn translate_document( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/TranslateDocument", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Translates a large volume of text in asynchronous batch mode."] #[doc = " This function provides real-time output as the inputs are being processed."] #[doc = " If caller cancels a request, the partial results (for an input file, it's"] #[doc = " all or nothing) may still be available on the specified output location."] #[doc = ""] #[doc = " This call returns immediately and you can"] #[doc = " use google.longrunning.Operation.name to poll the status of the call."] pub async fn batch_translate_text( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/BatchTranslateText", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Translates a large volume of documents in asynchronous batch mode."] #[doc = " This function provides real-time output as the inputs are being processed."] #[doc = " If caller cancels a request, the partial results (for an input file, it's"] #[doc = " all or nothing) may still be available on the specified output location."] #[doc = ""] #[doc = " This call returns immediately and you can use"] #[doc = " google.longrunning.Operation.name to poll the status of the call."] pub async fn batch_translate_document( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/BatchTranslateDocument", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates a glossary and returns the long-running operation. Returns"] #[doc = " NOT_FOUND, if the project doesn't exist."] pub async fn create_glossary( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/CreateGlossary", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't"] #[doc = " exist."] pub async fn list_glossaries( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/ListGlossaries", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets a glossary. Returns NOT_FOUND, if the glossary doesn't"] #[doc = " exist."] pub async fn get_glossary( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/GetGlossary", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Deletes a glossary, or cancels glossary construction"] #[doc = " if the glossary isn't created yet."] #[doc = " Returns NOT_FOUND, if the glossary doesn't exist."] pub async fn delete_glossary( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.translation.v3beta1.TranslationService/DeleteGlossary", ); self.inner.unary(request.into_request(), path, codec).await } } }