/// A vertex represents a 2D point in the image. /// NOTE: the vertex coordinates are in the same scale as the original image. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Vertex { /// X coordinate. #[prost(int32, tag = "1")] pub x: i32, /// Y coordinate. #[prost(int32, tag = "2")] pub y: i32, } /// A vertex represents a 2D point in the image. /// NOTE: the normalized vertex coordinates are relative to the original image /// and range from 0 to 1. #[derive(Clone, PartialEq, ::prost::Message)] pub struct NormalizedVertex { /// X coordinate. #[prost(float, tag = "1")] pub x: f32, /// Y coordinate. #[prost(float, tag = "2")] pub y: f32, } /// A bounding polygon for the detected image annotation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BoundingPoly { /// The bounding polygon vertices. #[prost(message, repeated, tag = "1")] pub vertices: ::prost::alloc::vec::Vec, /// The bounding polygon normalized vertices. #[prost(message, repeated, tag = "2")] pub normalized_vertices: ::prost::alloc::vec::Vec, } /// A 3D position in the image, used primarily for Face detection landmarks. /// A valid Position must have both x and y coordinates. /// The position coordinates are in the same scale as the original image. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Position { /// X coordinate. #[prost(float, tag = "1")] pub x: f32, /// Y coordinate. #[prost(float, tag = "2")] pub y: f32, /// Z coordinate (or depth). #[prost(float, tag = "3")] pub z: f32, } /// Parameters for a celebrity recognition request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FaceRecognitionParams { /// The resource names for one or more /// \[CelebritySet][google.cloud.vision.v1p4beta1.CelebritySet\]s. A celebrity /// set is preloaded and can be specified as "builtin/default". If this is /// specified, the algorithm will try to match the faces detected in the input /// image to the Celebrities in the CelebritySets. #[prost(string, repeated, tag = "1")] pub celebrity_set: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// A Celebrity is a group of Faces with an identity. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Celebrity { /// The resource name of the preloaded Celebrity. Has the format /// `builtin/{mid}`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The Celebrity's display name. #[prost(string, tag = "2")] pub display_name: ::prost::alloc::string::String, /// The Celebrity's description. #[prost(string, tag = "3")] pub description: ::prost::alloc::string::String, } /// Information about a face's identity. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FaceRecognitionResult { /// The \[Celebrity][google.cloud.vision.v1p4beta1.Celebrity\] that this face was /// matched to. #[prost(message, optional, tag = "1")] pub celebrity: ::core::option::Option, /// Recognition confidence. Range [0, 1]. #[prost(float, tag = "2")] pub confidence: f32, } /// A Product contains ReferenceImages. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Product { /// The resource name of the product. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID`. /// /// This field is ignored when creating a product. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The user-provided name for this Product. Must not be empty. Must be at most /// 4096 characters long. #[prost(string, tag = "2")] pub display_name: ::prost::alloc::string::String, /// User-provided metadata to be stored with this product. Must be at most 4096 /// characters long. #[prost(string, tag = "3")] pub description: ::prost::alloc::string::String, /// Immutable. The category for the product identified by the reference image. /// This should be either "homegoods-v2", "apparel-v2", or "toys-v2". The /// legacy categories "homegoods", "apparel", and "toys" are still supported, /// but these should not be used for new products. #[prost(string, tag = "4")] pub product_category: ::prost::alloc::string::String, /// Key-value pairs that can be attached to a product. At query time, /// constraints can be specified based on the product_labels. /// /// Note that integer values can be provided as strings, e.g. "1199". Only /// strings with integer values can match a range-based restriction which is /// to be supported soon. /// /// Multiple values can be assigned to the same key. One product may have up to /// 500 product_labels. /// /// Notice that the total number of distinct product_labels over all products /// in one ProductSet cannot exceed 1M, otherwise the product search pipeline /// will refuse to work for that ProductSet. #[prost(message, repeated, tag = "5")] pub product_labels: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `Product`. pub mod product { /// A product label represented as a key-value pair. #[derive(Clone, PartialEq, ::prost::Message)] pub struct KeyValue { /// The key of the label attached to the product. Cannot be empty and cannot /// exceed 128 bytes. #[prost(string, tag = "1")] pub key: ::prost::alloc::string::String, /// The value of the label attached to the product. Cannot be empty and /// cannot exceed 128 bytes. #[prost(string, tag = "2")] pub value: ::prost::alloc::string::String, } } /// A ProductSet contains Products. A ProductSet can contain a maximum of 1 /// million reference images. If the limit is exceeded, periodic indexing will /// fail. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ProductSet { /// The resource name of the ProductSet. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID`. /// /// This field is ignored when creating a ProductSet. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The user-provided name for this ProductSet. Must not be empty. Must be at /// most 4096 characters long. #[prost(string, tag = "2")] pub display_name: ::prost::alloc::string::String, /// Output only. The time at which this ProductSet was last indexed. Query /// results will reflect all updates before this time. If this ProductSet has /// never been indexed, this timestamp is the default value /// "1970-01-01T00:00:00Z". /// /// This field is ignored when creating a ProductSet. #[prost(message, optional, tag = "3")] pub index_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. If there was an error with indexing the product set, the field /// is populated. /// /// This field is ignored when creating a ProductSet. #[prost(message, optional, tag = "4")] pub index_error: ::core::option::Option, } /// A `ReferenceImage` represents a product image and its associated metadata, /// such as bounding boxes. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ReferenceImage { /// The resource name of the reference image. /// /// Format is: /// /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID/referenceImages/IMAGE_ID`. /// /// This field is ignored when creating a reference image. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Required. The Google Cloud Storage URI of the reference image. /// /// The URI must start with `gs://`. #[prost(string, tag = "2")] pub uri: ::prost::alloc::string::String, /// Optional. Bounding polygons around the areas of interest in the reference /// image. If this field is empty, the system will try to detect regions of /// interest. At most 10 bounding polygons will be used. /// /// The provided shape is converted into a non-rotated rectangle. Once /// converted, the small edge of the rectangle must be greater than or equal /// to 300 pixels. The aspect ratio must be 1:4 or less (i.e. 1:3 is ok; 1:5 /// is not). #[prost(message, repeated, tag = "3")] pub bounding_polys: ::prost::alloc::vec::Vec, } /// Request message for the `CreateProduct` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateProductRequest { /// Required. The project in which the Product should be created. /// /// Format is /// `projects/PROJECT_ID/locations/LOC_ID`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The product to create. #[prost(message, optional, tag = "2")] pub product: ::core::option::Option, /// A user-supplied resource id for this Product. If set, the server will /// attempt to use this value as the resource id. If it is already in use, an /// error is returned with code ALREADY_EXISTS. Must be at most 128 characters /// long. It cannot contain the character `/`. #[prost(string, tag = "3")] pub product_id: ::prost::alloc::string::String, } /// Request message for the `ListProducts` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListProductsRequest { /// Required. The project OR ProductSet from which Products should be listed. /// /// Format: /// `projects/PROJECT_ID/locations/LOC_ID` #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// The maximum number of items to return. Default 10, maximum 100. #[prost(int32, tag = "2")] pub page_size: i32, /// The next_page_token returned from a previous List request, if any. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, } /// Response message for the `ListProducts` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListProductsResponse { /// List of products. #[prost(message, repeated, tag = "1")] pub products: ::prost::alloc::vec::Vec, /// Token to retrieve the next page of results, or empty if there are no more /// results in the list. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// Request message for the `GetProduct` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetProductRequest { /// Required. Resource name of the Product to get. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for the `UpdateProduct` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateProductRequest { /// Required. The Product resource which replaces the one on the server. /// product.name is immutable. #[prost(message, optional, tag = "1")] pub product: ::core::option::Option, /// The \[FieldMask][google.protobuf.FieldMask\] that specifies which fields /// to update. /// If update_mask isn't specified, all mutable fields are to be updated. /// Valid mask paths include `product_labels`, `display_name`, and /// `description`. #[prost(message, optional, tag = "2")] pub update_mask: ::core::option::Option<::prost_types::FieldMask>, } /// Request message for the `DeleteProduct` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteProductRequest { /// Required. Resource name of product to delete. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for the `CreateProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateProductSetRequest { /// Required. The project in which the ProductSet should be created. /// /// Format is `projects/PROJECT_ID/locations/LOC_ID`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The ProductSet to create. #[prost(message, optional, tag = "2")] pub product_set: ::core::option::Option, /// A user-supplied resource id for this ProductSet. If set, the server will /// attempt to use this value as the resource id. If it is already in use, an /// error is returned with code ALREADY_EXISTS. Must be at most 128 characters /// long. It cannot contain the character `/`. #[prost(string, tag = "3")] pub product_set_id: ::prost::alloc::string::String, } /// Request message for the `ListProductSets` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListProductSetsRequest { /// Required. The project from which ProductSets should be listed. /// /// Format is `projects/PROJECT_ID/locations/LOC_ID`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// The maximum number of items to return. Default 10, maximum 100. #[prost(int32, tag = "2")] pub page_size: i32, /// The next_page_token returned from a previous List request, if any. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, } /// Response message for the `ListProductSets` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListProductSetsResponse { /// List of ProductSets. #[prost(message, repeated, tag = "1")] pub product_sets: ::prost::alloc::vec::Vec, /// Token to retrieve the next page of results, or empty if there are no more /// results in the list. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// Request message for the `GetProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetProductSetRequest { /// Required. Resource name of the ProductSet to get. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for the `UpdateProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateProductSetRequest { /// Required. The ProductSet resource which replaces the one on the server. #[prost(message, optional, tag = "1")] pub product_set: ::core::option::Option, /// The \[FieldMask][google.protobuf.FieldMask\] that specifies which fields to /// update. /// If update_mask isn't specified, all mutable fields are to be updated. /// Valid mask path is `display_name`. #[prost(message, optional, tag = "2")] pub update_mask: ::core::option::Option<::prost_types::FieldMask>, } /// Request message for the `DeleteProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteProductSetRequest { /// Required. Resource name of the ProductSet to delete. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for the `CreateReferenceImage` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateReferenceImageRequest { /// Required. Resource name of the product in which to create the reference /// image. /// /// Format is /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The reference image to create. /// If an image ID is specified, it is ignored. #[prost(message, optional, tag = "2")] pub reference_image: ::core::option::Option, /// A user-supplied resource id for the ReferenceImage to be added. If set, /// the server will attempt to use this value as the resource id. If it is /// already in use, an error is returned with code ALREADY_EXISTS. Must be at /// most 128 characters long. It cannot contain the character `/`. #[prost(string, tag = "3")] pub reference_image_id: ::prost::alloc::string::String, } /// Request message for the `ListReferenceImages` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListReferenceImagesRequest { /// Required. Resource name of the product containing the reference images. /// /// Format is /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// The maximum number of items to return. Default 10, maximum 100. #[prost(int32, tag = "2")] pub page_size: i32, /// A token identifying a page of results to be returned. This is the value /// of `nextPageToken` returned in a previous reference image list request. /// /// Defaults to the first page if not specified. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, } /// Response message for the `ListReferenceImages` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListReferenceImagesResponse { /// The list of reference images. #[prost(message, repeated, tag = "1")] pub reference_images: ::prost::alloc::vec::Vec, /// The maximum number of items to return. Default 10, maximum 100. #[prost(int32, tag = "2")] pub page_size: i32, /// The next_page_token returned from a previous List request, if any. #[prost(string, tag = "3")] pub next_page_token: ::prost::alloc::string::String, } /// Request message for the `GetReferenceImage` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetReferenceImageRequest { /// Required. The resource name of the ReferenceImage to get. /// /// Format is: /// /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID/referenceImages/IMAGE_ID`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for the `DeleteReferenceImage` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteReferenceImageRequest { /// Required. The resource name of the reference image to delete. /// /// Format is: /// /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID/referenceImages/IMAGE_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for the `AddProductToProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AddProductToProductSetRequest { /// Required. The resource name for the ProductSet to modify. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Required. The resource name for the Product to be added to this ProductSet. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID` #[prost(string, tag = "2")] pub product: ::prost::alloc::string::String, } /// Request message for the `RemoveProductFromProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RemoveProductFromProductSetRequest { /// Required. The resource name for the ProductSet to modify. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Required. The resource name for the Product to be removed from this /// ProductSet. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID` #[prost(string, tag = "2")] pub product: ::prost::alloc::string::String, } /// Request message for the `ListProductsInProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListProductsInProductSetRequest { /// Required. The ProductSet resource for which to retrieve Products. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The maximum number of items to return. Default 10, maximum 100. #[prost(int32, tag = "2")] pub page_size: i32, /// The next_page_token returned from a previous List request, if any. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, } /// Response message for the `ListProductsInProductSet` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListProductsInProductSetResponse { /// The list of Products. #[prost(message, repeated, tag = "1")] pub products: ::prost::alloc::vec::Vec, /// Token to retrieve the next page of results, or empty if there are no more /// results in the list. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// The Google Cloud Storage location for a csv file which preserves a list of /// ImportProductSetRequests in each line. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImportProductSetsGcsSource { /// The Google Cloud Storage URI of the input csv file. /// /// The URI must start with `gs://`. /// /// The format of the input csv file should be one image per line. /// In each line, there are 8 columns. /// /// 1. image-uri /// 2. image-id /// 3. product-set-id /// 4. product-id /// 5. product-category /// 6. product-display-name /// 7. labels /// 8. bounding-poly /// /// The `image-uri`, `product-set-id`, `product-id`, and `product-category` /// columns are required. All other columns are optional. /// /// If the `ProductSet` or `Product` specified by the `product-set-id` and /// `product-id` values does not exist, then the system will create a new /// `ProductSet` or `Product` for the image. In this case, the /// `product-display-name` column refers to /// \[display_name][google.cloud.vision.v1p4beta1.Product.display_name\], the /// `product-category` column refers to /// \[product_category][google.cloud.vision.v1p4beta1.Product.product_category\], /// and the `labels` column refers to /// \[product_labels][google.cloud.vision.v1p4beta1.Product.product_labels\]. /// /// The `image-id` column is optional but must be unique if provided. If it is /// empty, the system will automatically assign a unique id to the image. /// /// The `product-display-name` column is optional. If it is empty, the system /// sets the \[display_name][google.cloud.vision.v1p4beta1.Product.display_name\] /// field for the product to a space (" "). You can update the `display_name` /// later by using the API. /// /// If a `Product` with the specified `product-id` already exists, then the /// system ignores the `product-display-name`, `product-category`, and `labels` /// columns. /// /// The `labels` column (optional) is a line containing a list of /// comma-separated key-value pairs, in the following format: /// /// "key_1=value_1,key_2=value_2,...,key_n=value_n" /// /// The `bounding-poly` column (optional) identifies one region of /// interest from the image in the same manner as `CreateReferenceImage`. If /// you do not specify the `bounding-poly` column, then the system will try to /// detect regions of interest automatically. /// /// At most one `bounding-poly` column is allowed per line. If the image /// contains multiple regions of interest, add a line to the CSV file that /// includes the same product information, and the `bounding-poly` values for /// each region of interest. /// /// The `bounding-poly` column must contain an even number of comma-separated /// numbers, in the format "p1_x,p1_y,p2_x,p2_y,...,pn_x,pn_y". Use /// non-negative integers for absolute bounding polygons, and float values /// in [0, 1] for normalized bounding polygons. /// /// The system will resize the image if the image resolution is too /// large to process (larger than 20MP). #[prost(string, tag = "1")] pub csv_file_uri: ::prost::alloc::string::String, } /// The input content for the `ImportProductSets` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImportProductSetsInputConfig { /// The source of the input. #[prost(oneof = "import_product_sets_input_config::Source", tags = "1")] pub source: ::core::option::Option, } /// Nested message and enum types in `ImportProductSetsInputConfig`. pub mod import_product_sets_input_config { /// The source of the input. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Source { /// The Google Cloud Storage location for a csv file which preserves a list /// of ImportProductSetRequests in each line. #[prost(message, tag = "1")] GcsSource(super::ImportProductSetsGcsSource), } } /// Request message for the `ImportProductSets` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImportProductSetsRequest { /// Required. The project in which the ProductSets should be imported. /// /// Format is `projects/PROJECT_ID/locations/LOC_ID`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The input content for the list of requests. #[prost(message, optional, tag = "2")] pub input_config: ::core::option::Option, } /// Response message for the `ImportProductSets` method. /// /// This message is returned by the /// \[google.longrunning.Operations.GetOperation][google.longrunning.Operations.GetOperation\] /// method in the returned /// \[google.longrunning.Operation.response][google.longrunning.Operation.response\] /// field. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImportProductSetsResponse { /// The list of reference_images that are imported successfully. #[prost(message, repeated, tag = "1")] pub reference_images: ::prost::alloc::vec::Vec, /// The rpc status for each ImportProductSet request, including both successes /// and errors. /// /// The number of statuses here matches the number of lines in the csv file, /// and statuses\[i\] stores the success or failure status of processing the i-th /// line of the csv, starting from line 0. #[prost(message, repeated, tag = "2")] pub statuses: ::prost::alloc::vec::Vec, } /// Metadata for the batch operations such as the current state. /// /// This is included in the `metadata` field of the `Operation` returned by the /// `GetOperation` call of the `google::longrunning::Operations` service. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchOperationMetadata { /// The current state of the batch operation. #[prost(enumeration = "batch_operation_metadata::State", tag = "1")] pub state: i32, /// The time when the batch request was submitted to the server. #[prost(message, optional, tag = "2")] pub submit_time: ::core::option::Option<::prost_types::Timestamp>, /// The time when the batch request 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>, } /// Nested message and enum types in `BatchOperationMetadata`. pub mod batch_operation_metadata { /// Enumerates the possible states that the batch 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 actively being processed. Processing = 1, /// The request is done and at least one item has been successfully /// processed. Successful = 2, /// The request is done and no item has been successfully processed. Failed = 3, /// The request is done after the longrunning.Operations.CancelOperation has /// been called by the user. Any records that were processed before the /// cancel command are output as specified in the request. Cancelled = 4, } } /// Config to control which ProductSet contains the Products to be deleted. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ProductSetPurgeConfig { /// The ProductSet that contains the Products to delete. If a Product is a /// member of product_set_id in addition to other ProductSets, the Product will /// still be deleted. #[prost(string, tag = "1")] pub product_set_id: ::prost::alloc::string::String, } /// Request message for the `PurgeProducts` method. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PurgeProductsRequest { /// Required. The project and location in which the Products should be deleted. /// /// Format is `projects/PROJECT_ID/locations/LOC_ID`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// The default value is false. Override this value to true to actually perform /// the purge. #[prost(bool, tag = "4")] pub force: bool, /// The Products to delete. #[prost(oneof = "purge_products_request::Target", tags = "2, 3")] pub target: ::core::option::Option, } /// Nested message and enum types in `PurgeProductsRequest`. pub mod purge_products_request { /// The Products to delete. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Target { /// Specify which ProductSet contains the Products to be deleted. #[prost(message, tag = "2")] ProductSetPurgeConfig(super::ProductSetPurgeConfig), /// If delete_orphan_products is true, all Products that are not in any /// ProductSet will be deleted. #[prost(bool, tag = "3")] DeleteOrphanProducts(bool), } } #[doc = r" Generated client implementations."] pub mod product_search_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " Manages Products and ProductSets of reference images for use in product"] #[doc = " search. It uses the following resource model:"] #[doc = ""] #[doc = " - The API has a collection of"] #[doc = " [ProductSet][google.cloud.vision.v1p4beta1.ProductSet] resources, named"] #[doc = " `projects/*/locations/*/productSets/*`, which acts as a way to put different"] #[doc = " products into groups to limit identification."] #[doc = ""] #[doc = " In parallel,"] #[doc = ""] #[doc = " - The API has a collection of"] #[doc = " [Product][google.cloud.vision.v1p4beta1.Product] resources, named"] #[doc = " `projects/*/locations/*/products/*`"] #[doc = ""] #[doc = " - Each [Product][google.cloud.vision.v1p4beta1.Product] has a collection of"] #[doc = " [ReferenceImage][google.cloud.vision.v1p4beta1.ReferenceImage] resources,"] #[doc = " named"] #[doc = " `projects/*/locations/*/products/*/referenceImages/*`"] #[derive(Debug, Clone)] pub struct ProductSearchClient { inner: tonic::client::Grpc, } impl ProductSearchClient 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, ) -> ProductSearchClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { ProductSearchClient::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 = " Creates and returns a new ProductSet resource."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns INVALID_ARGUMENT if display_name is missing, or is longer than"] #[doc = " 4096 characters."] pub async fn create_product_set( &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.vision.v1p4beta1.ProductSearch/CreateProductSet", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists ProductSets in an unspecified order."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns INVALID_ARGUMENT if page_size is greater than 100, or less"] #[doc = " than 1."] pub async fn list_product_sets( &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.vision.v1p4beta1.ProductSearch/ListProductSets", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets information associated with a ProductSet."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns NOT_FOUND if the ProductSet does not exist."] pub async fn get_product_set( &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.vision.v1p4beta1.ProductSearch/GetProductSet", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Makes changes to a ProductSet resource."] #[doc = " Only display_name can be updated currently."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns NOT_FOUND if the ProductSet does not exist."] #[doc = " * Returns INVALID_ARGUMENT if display_name is present in update_mask but"] #[doc = " missing from the request or longer than 4096 characters."] pub async fn update_product_set( &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.vision.v1p4beta1.ProductSearch/UpdateProductSet", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Permanently deletes a ProductSet. Products and ReferenceImages in the"] #[doc = " ProductSet are not deleted."] #[doc = ""] #[doc = " The actual image files are not deleted from Google Cloud Storage."] pub async fn delete_product_set( &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.vision.v1p4beta1.ProductSearch/DeleteProductSet", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates and returns a new product resource."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns INVALID_ARGUMENT if display_name is missing or longer than 4096"] #[doc = " characters."] #[doc = " * Returns INVALID_ARGUMENT if description is longer than 4096 characters."] #[doc = " * Returns INVALID_ARGUMENT if product_category is missing or invalid."] pub async fn create_product( &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.vision.v1p4beta1.ProductSearch/CreateProduct", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists products in an unspecified order."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns INVALID_ARGUMENT if page_size is greater than 100 or less than 1."] pub async fn list_products( &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.vision.v1p4beta1.ProductSearch/ListProducts", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets information associated with a Product."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns NOT_FOUND if the Product does not exist."] pub async fn get_product( &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.vision.v1p4beta1.ProductSearch/GetProduct", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Makes changes to a Product resource."] #[doc = " Only the `display_name`, `description`, and `labels` fields can be updated"] #[doc = " right now."] #[doc = ""] #[doc = " If labels are updated, the change will not be reflected in queries until"] #[doc = " the next index time."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns NOT_FOUND if the Product does not exist."] #[doc = " * Returns INVALID_ARGUMENT if display_name is present in update_mask but is"] #[doc = " missing from the request or longer than 4096 characters."] #[doc = " * Returns INVALID_ARGUMENT if description is present in update_mask but is"] #[doc = " longer than 4096 characters."] #[doc = " * Returns INVALID_ARGUMENT if product_category is present in update_mask."] pub async fn update_product( &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.vision.v1p4beta1.ProductSearch/UpdateProduct", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Permanently deletes a product and its reference images."] #[doc = ""] #[doc = " Metadata of the product and all its images will be deleted right away, but"] #[doc = " search queries against ProductSets containing the product may still work"] #[doc = " until all related caches are refreshed."] pub async fn delete_product( &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.vision.v1p4beta1.ProductSearch/DeleteProduct", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates and returns a new ReferenceImage resource."] #[doc = ""] #[doc = " The `bounding_poly` field is optional. If `bounding_poly` is not specified,"] #[doc = " the system will try to detect regions of interest in the image that are"] #[doc = " compatible with the product_category on the parent product. If it is"] #[doc = " specified, detection is ALWAYS skipped. The system converts polygons into"] #[doc = " non-rotated rectangles."] #[doc = ""] #[doc = " Note that the pipeline will resize the image if the image resolution is too"] #[doc = " large to process (above 50MP)."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns INVALID_ARGUMENT if the image_uri is missing or longer than 4096"] #[doc = " characters."] #[doc = " * Returns INVALID_ARGUMENT if the product does not exist."] #[doc = " * Returns INVALID_ARGUMENT if bounding_poly is not provided, and nothing"] #[doc = " compatible with the parent product's product_category is detected."] #[doc = " * Returns INVALID_ARGUMENT if bounding_poly contains more than 10 polygons."] pub async fn create_reference_image( &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.vision.v1p4beta1.ProductSearch/CreateReferenceImage", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Permanently deletes a reference image."] #[doc = ""] #[doc = " The image metadata will be deleted right away, but search queries"] #[doc = " against ProductSets containing the image may still work until all related"] #[doc = " caches are refreshed."] #[doc = ""] #[doc = " The actual image files are not deleted from Google Cloud Storage."] pub async fn delete_reference_image( &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.vision.v1p4beta1.ProductSearch/DeleteReferenceImage", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists reference images."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns NOT_FOUND if the parent product does not exist."] #[doc = " * Returns INVALID_ARGUMENT if the page_size is greater than 100, or less"] #[doc = " than 1."] pub async fn list_reference_images( &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.vision.v1p4beta1.ProductSearch/ListReferenceImages", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets information associated with a ReferenceImage."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns NOT_FOUND if the specified image does not exist."] pub async fn get_reference_image( &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.vision.v1p4beta1.ProductSearch/GetReferenceImage", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Adds a Product to the specified ProductSet. If the Product is already"] #[doc = " present, no change is made."] #[doc = ""] #[doc = " One Product can be added to at most 100 ProductSets."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns NOT_FOUND if the Product or the ProductSet doesn't exist."] pub async fn add_product_to_product_set( &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.vision.v1p4beta1.ProductSearch/AddProductToProductSet", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Removes a Product from the specified ProductSet."] pub async fn remove_product_from_product_set( &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.vision.v1p4beta1.ProductSearch/RemoveProductFromProductSet", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists the Products in a ProductSet, in an unspecified order. If the"] #[doc = " ProductSet does not exist, the products field of the response will be"] #[doc = " empty."] #[doc = ""] #[doc = " Possible errors:"] #[doc = ""] #[doc = " * Returns INVALID_ARGUMENT if page_size is greater than 100 or less than 1."] pub async fn list_products_in_product_set( &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.vision.v1p4beta1.ProductSearch/ListProductsInProductSet", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Asynchronous API that imports a list of reference images to specified"] #[doc = " product sets based on a list of image information."] #[doc = ""] #[doc = " The [google.longrunning.Operation][google.longrunning.Operation] API can be"] #[doc = " used to keep track of the progress and results of the request."] #[doc = " `Operation.metadata` contains `BatchOperationMetadata`. (progress)"] #[doc = " `Operation.response` contains `ImportProductSetsResponse`. (results)"] #[doc = ""] #[doc = " The input source of this method is a csv file on Google Cloud Storage."] #[doc = " For the format of the csv file please see"] #[doc = " [ImportProductSetsGcsSource.csv_file_uri][google.cloud.vision.v1p4beta1.ImportProductSetsGcsSource.csv_file_uri]."] pub async fn import_product_sets( &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.vision.v1p4beta1.ProductSearch/ImportProductSets", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Asynchronous API to delete all Products in a ProductSet or all Products"] #[doc = " that are in no ProductSet."] #[doc = ""] #[doc = " If a Product is a member of the specified ProductSet in addition to other"] #[doc = " ProductSets, the Product will still be deleted."] #[doc = ""] #[doc = " It is recommended to not delete the specified ProductSet until after this"] #[doc = " operation has completed. It is also recommended to not add any of the"] #[doc = " Products involved in the batch delete to a new ProductSet while this"] #[doc = " operation is running because those Products may still end up deleted."] #[doc = ""] #[doc = " It's not possible to undo the PurgeProducts operation. Therefore, it is"] #[doc = " recommended to keep the csv files used in ImportProductSets (if that was"] #[doc = " how you originally built the Product Set) before starting PurgeProducts, in"] #[doc = " case you need to re-import the data after deletion."] #[doc = ""] #[doc = " If the plan is to purge all of the Products from a ProductSet and then"] #[doc = " re-use the empty ProductSet to re-import new Products into the empty"] #[doc = " ProductSet, you must wait until the PurgeProducts operation has finished"] #[doc = " for that ProductSet."] #[doc = ""] #[doc = " The [google.longrunning.Operation][google.longrunning.Operation] API can be"] #[doc = " used to keep track of the progress and results of the request."] #[doc = " `Operation.metadata` contains `BatchOperationMetadata`. (progress)"] pub async fn purge_products( &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.vision.v1p4beta1.ProductSearch/PurgeProducts", ); self.inner.unary(request.into_request(), path, codec).await } } } /// Parameters for a product search request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ProductSearchParams { /// The bounding polygon around the area of interest in the image. /// If it is not specified, system discretion will be applied. #[prost(message, optional, tag = "9")] pub bounding_poly: ::core::option::Option, /// The resource name of a /// \[ProductSet][google.cloud.vision.v1p4beta1.ProductSet\] to be searched for /// similar images. /// /// Format is: /// `projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID`. #[prost(string, tag = "6")] pub product_set: ::prost::alloc::string::String, /// The list of product categories to search in. Currently, we only consider /// the first category, and either "homegoods-v2", "apparel-v2", "toys-v2", /// "packagedgoods-v1", or "general-v1" should be specified. The legacy /// categories "homegoods", "apparel", and "toys" are still supported but will /// be deprecated. For new products, please use "homegoods-v2", "apparel-v2", /// or "toys-v2" for better product search accuracy. It is recommended to /// migrate existing products to these categories as well. #[prost(string, repeated, tag = "7")] pub product_categories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The filtering expression. This can be used to restrict search results based /// on Product labels. We currently support an AND of OR of key-value /// expressions, where each expression within an OR must have the same key. An /// '=' should be used to connect the key and value. /// /// For example, "(color = red OR color = blue) AND brand = Google" is /// acceptable, but "(color = red OR brand = Google)" is not acceptable. /// "color: red" is not acceptable because it uses a ':' instead of an '='. #[prost(string, tag = "8")] pub filter: ::prost::alloc::string::String, } /// Results for a product search request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ProductSearchResults { /// Timestamp of the index which provided these results. Products added to the /// product set and products removed from the product set after this time are /// not reflected in the current results. #[prost(message, optional, tag = "2")] pub index_time: ::core::option::Option<::prost_types::Timestamp>, /// List of results, one for each product match. #[prost(message, repeated, tag = "5")] pub results: ::prost::alloc::vec::Vec, /// List of results grouped by products detected in the query image. Each entry /// corresponds to one bounding polygon in the query image, and contains the /// matching products specific to that region. There may be duplicate product /// matches in the union of all the per-product results. #[prost(message, repeated, tag = "6")] pub product_grouped_results: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `ProductSearchResults`. pub mod product_search_results { /// Information about a product. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Result { /// The Product. #[prost(message, optional, tag = "1")] pub product: ::core::option::Option, /// A confidence level on the match, ranging from 0 (no confidence) to /// 1 (full confidence). #[prost(float, tag = "2")] pub score: f32, /// The resource name of the image from the product that is the closest match /// to the query. #[prost(string, tag = "3")] pub image: ::prost::alloc::string::String, } /// Prediction for what the object in the bounding box is. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ObjectAnnotation { /// Object ID that should align with EntityAnnotation mid. #[prost(string, tag = "1")] pub mid: ::prost::alloc::string::String, /// The BCP-47 language code, such as "en-US" or "sr-Latn". For more /// information, see /// #[prost(string, tag = "2")] pub language_code: ::prost::alloc::string::String, /// Object name, expressed in its `language_code` language. #[prost(string, tag = "3")] pub name: ::prost::alloc::string::String, /// Score of the result. Range [0, 1]. #[prost(float, tag = "4")] pub score: f32, } /// Information about the products similar to a single product in a query /// image. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GroupedResult { /// The bounding polygon around the product detected in the query image. #[prost(message, optional, tag = "1")] pub bounding_poly: ::core::option::Option, /// List of results, one for each product match. #[prost(message, repeated, tag = "2")] pub results: ::prost::alloc::vec::Vec, /// List of generic predictions for the object in the bounding box. #[prost(message, repeated, tag = "3")] pub object_annotations: ::prost::alloc::vec::Vec, } } /// TextAnnotation contains a structured representation of OCR extracted text. /// The hierarchy of an OCR extracted text structure is like this: /// TextAnnotation -> Page -> Block -> Paragraph -> Word -> Symbol /// Each structural component, starting from Page, may further have their own /// properties. Properties describe detected languages, breaks etc.. Please refer /// to the /// \[TextAnnotation.TextProperty][google.cloud.vision.v1p4beta1.TextAnnotation.TextProperty\] /// message definition below for more detail. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TextAnnotation { /// List of pages detected by OCR. #[prost(message, repeated, tag = "1")] pub pages: ::prost::alloc::vec::Vec, /// UTF-8 text detected on the pages. #[prost(string, tag = "2")] pub text: ::prost::alloc::string::String, } /// Nested message and enum types in `TextAnnotation`. pub mod text_annotation { /// Detected language for a structural component. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DetectedLanguage { /// The BCP-47 language code, such as "en-US" or "sr-Latn". For more /// information, see /// #[prost(string, tag = "1")] pub language_code: ::prost::alloc::string::String, /// Confidence of detected language. Range [0, 1]. #[prost(float, tag = "2")] pub confidence: f32, } /// Detected start or end of a structural component. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DetectedBreak { /// Detected break type. #[prost(enumeration = "detected_break::BreakType", tag = "1")] pub r#type: i32, /// True if break prepends the element. #[prost(bool, tag = "2")] pub is_prefix: bool, } /// Nested message and enum types in `DetectedBreak`. pub mod detected_break { /// Enum to denote the type of break found. New line, space etc. #[derive( Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration, )] #[repr(i32)] pub enum BreakType { /// Unknown break label type. Unknown = 0, /// Regular space. Space = 1, /// Sure space (very wide). SureSpace = 2, /// Line-wrapping break. EolSureSpace = 3, /// End-line hyphen that is not present in text; does not co-occur with /// `SPACE`, `LEADER_SPACE`, or `LINE_BREAK`. Hyphen = 4, /// Line break that ends a paragraph. LineBreak = 5, } } /// Additional information detected on the structural component. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TextProperty { /// A list of detected languages together with confidence. #[prost(message, repeated, tag = "1")] pub detected_languages: ::prost::alloc::vec::Vec, /// Detected start or end of a text segment. #[prost(message, optional, tag = "2")] pub detected_break: ::core::option::Option, } } /// Detected page from OCR. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Page { /// Additional information detected on the page. #[prost(message, optional, tag = "1")] pub property: ::core::option::Option, /// Page width. For PDFs the unit is points. For images (including /// TIFFs) the unit is pixels. #[prost(int32, tag = "2")] pub width: i32, /// Page height. For PDFs the unit is points. For images (including /// TIFFs) the unit is pixels. #[prost(int32, tag = "3")] pub height: i32, /// List of blocks of text, images etc on this page. #[prost(message, repeated, tag = "4")] pub blocks: ::prost::alloc::vec::Vec, /// Confidence of the OCR results on the page. Range [0, 1]. #[prost(float, tag = "5")] pub confidence: f32, } /// Logical element on the page. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Block { /// Additional information detected for the block. #[prost(message, optional, tag = "1")] pub property: ::core::option::Option, /// The bounding box for the block. /// The vertices are in the order of top-left, top-right, bottom-right, /// bottom-left. When a rotation of the bounding box is detected the rotation /// is represented as around the top-left corner as defined when the text is /// read in the 'natural' orientation. /// For example: /// /// * when the text is horizontal it might look like: /// /// 0----1 /// | | /// 3----2 /// /// * when it's rotated 180 degrees around the top-left corner it becomes: /// /// 2----3 /// | | /// 1----0 /// /// and the vertex order will still be (0, 1, 2, 3). #[prost(message, optional, tag = "2")] pub bounding_box: ::core::option::Option, /// List of paragraphs in this block (if this blocks is of type text). #[prost(message, repeated, tag = "3")] pub paragraphs: ::prost::alloc::vec::Vec, /// Detected block type (text, image etc) for this block. #[prost(enumeration = "block::BlockType", tag = "4")] pub block_type: i32, /// Confidence of the OCR results on the block. Range [0, 1]. #[prost(float, tag = "5")] pub confidence: f32, } /// Nested message and enum types in `Block`. pub mod block { /// Type of a block (text, image etc) as identified by OCR. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum BlockType { /// Unknown block type. Unknown = 0, /// Regular text block. Text = 1, /// Table block. Table = 2, /// Image block. Picture = 3, /// Horizontal/vertical line box. Ruler = 4, /// Barcode block. Barcode = 5, } } /// Structural unit of text representing a number of words in certain order. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Paragraph { /// Additional information detected for the paragraph. #[prost(message, optional, tag = "1")] pub property: ::core::option::Option, /// The bounding box for the paragraph. /// The vertices are in the order of top-left, top-right, bottom-right, /// bottom-left. When a rotation of the bounding box is detected the rotation /// is represented as around the top-left corner as defined when the text is /// read in the 'natural' orientation. /// For example: /// * when the text is horizontal it might look like: /// 0----1 /// | | /// 3----2 /// * when it's rotated 180 degrees around the top-left corner it becomes: /// 2----3 /// | | /// 1----0 /// and the vertex order will still be (0, 1, 2, 3). #[prost(message, optional, tag = "2")] pub bounding_box: ::core::option::Option, /// List of all words in this paragraph. #[prost(message, repeated, tag = "3")] pub words: ::prost::alloc::vec::Vec, /// Confidence of the OCR results for the paragraph. Range [0, 1]. #[prost(float, tag = "4")] pub confidence: f32, } /// A word representation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Word { /// Additional information detected for the word. #[prost(message, optional, tag = "1")] pub property: ::core::option::Option, /// The bounding box for the word. /// The vertices are in the order of top-left, top-right, bottom-right, /// bottom-left. When a rotation of the bounding box is detected the rotation /// is represented as around the top-left corner as defined when the text is /// read in the 'natural' orientation. /// For example: /// * when the text is horizontal it might look like: /// 0----1 /// | | /// 3----2 /// * when it's rotated 180 degrees around the top-left corner it becomes: /// 2----3 /// | | /// 1----0 /// and the vertex order will still be (0, 1, 2, 3). #[prost(message, optional, tag = "2")] pub bounding_box: ::core::option::Option, /// List of symbols in the word. /// The order of the symbols follows the natural reading order. #[prost(message, repeated, tag = "3")] pub symbols: ::prost::alloc::vec::Vec, /// Confidence of the OCR results for the word. Range [0, 1]. #[prost(float, tag = "4")] pub confidence: f32, } /// A single symbol representation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Symbol { /// Additional information detected for the symbol. #[prost(message, optional, tag = "1")] pub property: ::core::option::Option, /// The bounding box for the symbol. /// The vertices are in the order of top-left, top-right, bottom-right, /// bottom-left. When a rotation of the bounding box is detected the rotation /// is represented as around the top-left corner as defined when the text is /// read in the 'natural' orientation. /// For example: /// * when the text is horizontal it might look like: /// 0----1 /// | | /// 3----2 /// * when it's rotated 180 degrees around the top-left corner it becomes: /// 2----3 /// | | /// 1----0 /// and the vertex order will still be (0, 1, 2, 3). #[prost(message, optional, tag = "2")] pub bounding_box: ::core::option::Option, /// The actual UTF-8 representation of the symbol. #[prost(string, tag = "3")] pub text: ::prost::alloc::string::String, /// Confidence of the OCR results for the symbol. Range [0, 1]. #[prost(float, tag = "4")] pub confidence: f32, } /// Relevant information for the image from the Internet. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WebDetection { /// Deduced entities from similar images on the Internet. #[prost(message, repeated, tag = "1")] pub web_entities: ::prost::alloc::vec::Vec, /// Fully matching images from the Internet. /// Can include resized copies of the query image. #[prost(message, repeated, tag = "2")] pub full_matching_images: ::prost::alloc::vec::Vec, /// Partial matching images from the Internet. /// Those images are similar enough to share some key-point features. For /// example an original image will likely have partial matching for its crops. #[prost(message, repeated, tag = "3")] pub partial_matching_images: ::prost::alloc::vec::Vec, /// Web pages containing the matching images from the Internet. #[prost(message, repeated, tag = "4")] pub pages_with_matching_images: ::prost::alloc::vec::Vec, /// The visually similar image results. #[prost(message, repeated, tag = "6")] pub visually_similar_images: ::prost::alloc::vec::Vec, /// The service's best guess as to the topic of the request image. /// Inferred from similar images on the open web. #[prost(message, repeated, tag = "8")] pub best_guess_labels: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `WebDetection`. pub mod web_detection { /// Entity deduced from similar images on the Internet. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WebEntity { /// Opaque entity ID. #[prost(string, tag = "1")] pub entity_id: ::prost::alloc::string::String, /// Overall relevancy score for the entity. /// Not normalized and not comparable across different image queries. #[prost(float, tag = "2")] pub score: f32, /// Canonical description of the entity, in English. #[prost(string, tag = "3")] pub description: ::prost::alloc::string::String, } /// Metadata for online images. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WebImage { /// The result image URL. #[prost(string, tag = "1")] pub url: ::prost::alloc::string::String, /// (Deprecated) Overall relevancy score for the image. #[prost(float, tag = "2")] pub score: f32, } /// Metadata for web pages. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WebPage { /// The result web page URL. #[prost(string, tag = "1")] pub url: ::prost::alloc::string::String, /// (Deprecated) Overall relevancy score for the web page. #[prost(float, tag = "2")] pub score: f32, /// Title for the web page, may contain HTML markups. #[prost(string, tag = "3")] pub page_title: ::prost::alloc::string::String, /// Fully matching images on the page. /// Can include resized copies of the query image. #[prost(message, repeated, tag = "4")] pub full_matching_images: ::prost::alloc::vec::Vec, /// Partial matching images on the page. /// Those images are similar enough to share some key-point features. For /// example an original image will likely have partial matching for its /// crops. #[prost(message, repeated, tag = "5")] pub partial_matching_images: ::prost::alloc::vec::Vec, } /// Label to provide extra metadata for the web detection. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WebLabel { /// Label for extra metadata. #[prost(string, tag = "1")] pub label: ::prost::alloc::string::String, /// The BCP-47 language code for `label`, such as "en-US" or "sr-Latn". /// For more information, see /// #[prost(string, tag = "2")] pub language_code: ::prost::alloc::string::String, } } /// The type of Google Cloud Vision API detection to perform, and the maximum /// number of results to return for that type. Multiple `Feature` objects can /// be specified in the `features` list. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Feature { /// The feature type. #[prost(enumeration = "feature::Type", tag = "1")] pub r#type: i32, /// Maximum number of results of this type. Does not apply to /// `TEXT_DETECTION`, `DOCUMENT_TEXT_DETECTION`, or `CROP_HINTS`. #[prost(int32, tag = "2")] pub max_results: i32, /// Model to use for the feature. /// Supported values: "builtin/stable" (the default if unset) and /// "builtin/latest". #[prost(string, tag = "3")] pub model: ::prost::alloc::string::String, } /// Nested message and enum types in `Feature`. pub mod feature { /// Type of Google Cloud Vision API feature to be extracted. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Type { /// Unspecified feature type. Unspecified = 0, /// Run face detection. FaceDetection = 1, /// Run landmark detection. LandmarkDetection = 2, /// Run logo detection. LogoDetection = 3, /// Run label detection. LabelDetection = 4, /// Run text detection / optical character recognition (OCR). Text detection /// is optimized for areas of text within a larger image; if the image is /// a document, use `DOCUMENT_TEXT_DETECTION` instead. TextDetection = 5, /// Run dense text document OCR. Takes precedence when both /// `DOCUMENT_TEXT_DETECTION` and `TEXT_DETECTION` are present. DocumentTextDetection = 11, /// Run Safe Search to detect potentially unsafe /// or undesirable content. SafeSearchDetection = 6, /// Compute a set of image properties, such as the /// image's dominant colors. ImageProperties = 7, /// Run crop hints. CropHints = 9, /// Run web detection. WebDetection = 10, /// Run Product Search. ProductSearch = 12, /// Run localizer for object detection. ObjectLocalization = 19, } } /// External image source (Google Cloud Storage or web URL image location). #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImageSource { /// **Use `image_uri` instead.** /// /// The Google Cloud Storage URI of the form /// `gs://bucket_name/object_name`. Object versioning is not supported. See /// [Google Cloud Storage Request /// URIs]() for more info. #[prost(string, tag = "1")] pub gcs_image_uri: ::prost::alloc::string::String, /// The URI of the source image. Can be either: /// /// 1. A Google Cloud Storage URI of the form /// `gs://bucket_name/object_name`. Object versioning is not supported. See /// [Google Cloud Storage Request /// URIs]() for more /// info. /// /// 2. A publicly-accessible image HTTP/HTTPS URL. When fetching images from /// HTTP/HTTPS URLs, Google cannot guarantee that the request will be /// completed. Your request may fail if the specified host denies the /// request (e.g. due to request throttling or DOS prevention), or if Google /// throttles requests to the site for abuse prevention. You should not /// depend on externally-hosted images for production applications. /// /// When both `gcs_image_uri` and `image_uri` are specified, `image_uri` takes /// precedence. #[prost(string, tag = "2")] pub image_uri: ::prost::alloc::string::String, } /// Client image to perform Google Cloud Vision API tasks over. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Image { /// Image content, represented as a stream of bytes. /// Note: As with all `bytes` fields, protobuffers use a pure binary /// representation, whereas JSON representations use base64. #[prost(bytes = "vec", tag = "1")] pub content: ::prost::alloc::vec::Vec, /// Google Cloud Storage image location, or publicly-accessible image /// URL. If both `content` and `source` are provided for an image, `content` /// takes precedence and is used to perform the image annotation request. #[prost(message, optional, tag = "2")] pub source: ::core::option::Option, } /// A face annotation object contains the results of face detection. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FaceAnnotation { /// The bounding polygon around the face. The coordinates of the bounding box /// are in the original image's scale. /// The bounding box is computed to "frame" the face in accordance with human /// expectations. It is based on the landmarker results. /// Note that one or more x and/or y coordinates may not be generated in the /// `BoundingPoly` (the polygon will be unbounded) if only a partial face /// appears in the image to be annotated. #[prost(message, optional, tag = "1")] pub bounding_poly: ::core::option::Option, /// The `fd_bounding_poly` bounding polygon is tighter than the /// `boundingPoly`, and encloses only the skin part of the face. Typically, it /// is used to eliminate the face from any image analysis that detects the /// "amount of skin" visible in an image. It is not based on the /// landmarker results, only on the initial face detection, hence /// the fd (face detection) prefix. #[prost(message, optional, tag = "2")] pub fd_bounding_poly: ::core::option::Option, /// Detected face landmarks. #[prost(message, repeated, tag = "3")] pub landmarks: ::prost::alloc::vec::Vec, /// Roll angle, which indicates the amount of clockwise/anti-clockwise rotation /// of the face relative to the image vertical about the axis perpendicular to /// the face. Range \[-180,180\]. #[prost(float, tag = "4")] pub roll_angle: f32, /// Yaw angle, which indicates the leftward/rightward angle that the face is /// pointing relative to the vertical plane perpendicular to the image. Range /// \[-180,180\]. #[prost(float, tag = "5")] pub pan_angle: f32, /// Pitch angle, which indicates the upwards/downwards angle that the face is /// pointing relative to the image's horizontal plane. Range \[-180,180\]. #[prost(float, tag = "6")] pub tilt_angle: f32, /// Detection confidence. Range [0, 1]. #[prost(float, tag = "7")] pub detection_confidence: f32, /// Face landmarking confidence. Range [0, 1]. #[prost(float, tag = "8")] pub landmarking_confidence: f32, /// Joy likelihood. #[prost(enumeration = "Likelihood", tag = "9")] pub joy_likelihood: i32, /// Sorrow likelihood. #[prost(enumeration = "Likelihood", tag = "10")] pub sorrow_likelihood: i32, /// Anger likelihood. #[prost(enumeration = "Likelihood", tag = "11")] pub anger_likelihood: i32, /// Surprise likelihood. #[prost(enumeration = "Likelihood", tag = "12")] pub surprise_likelihood: i32, /// Under-exposed likelihood. #[prost(enumeration = "Likelihood", tag = "13")] pub under_exposed_likelihood: i32, /// Blurred likelihood. #[prost(enumeration = "Likelihood", tag = "14")] pub blurred_likelihood: i32, /// Headwear likelihood. #[prost(enumeration = "Likelihood", tag = "15")] pub headwear_likelihood: i32, /// Additional recognition information. Only computed if /// image_context.face_recognition_params is provided, **and** a match is found /// to a \[Celebrity][google.cloud.vision.v1p4beta1.Celebrity\] in the input /// \[CelebritySet][google.cloud.vision.v1p4beta1.CelebritySet\]. This field is /// sorted in order of decreasing confidence values. #[prost(message, repeated, tag = "16")] pub recognition_result: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `FaceAnnotation`. pub mod face_annotation { /// A face-specific landmark (for example, a face feature). #[derive(Clone, PartialEq, ::prost::Message)] pub struct Landmark { /// Face landmark type. #[prost(enumeration = "landmark::Type", tag = "3")] pub r#type: i32, /// Face landmark position. #[prost(message, optional, tag = "4")] pub position: ::core::option::Option, } /// Nested message and enum types in `Landmark`. pub mod landmark { /// Face landmark (feature) type. /// Left and right are defined from the vantage of the viewer of the image /// without considering mirror projections typical of photos. So, `LEFT_EYE`, /// typically, is the person's right eye. #[derive( Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration, )] #[repr(i32)] pub enum Type { /// Unknown face landmark detected. Should not be filled. UnknownLandmark = 0, /// Left eye. LeftEye = 1, /// Right eye. RightEye = 2, /// Left of left eyebrow. LeftOfLeftEyebrow = 3, /// Right of left eyebrow. RightOfLeftEyebrow = 4, /// Left of right eyebrow. LeftOfRightEyebrow = 5, /// Right of right eyebrow. RightOfRightEyebrow = 6, /// Midpoint between eyes. MidpointBetweenEyes = 7, /// Nose tip. NoseTip = 8, /// Upper lip. UpperLip = 9, /// Lower lip. LowerLip = 10, /// Mouth left. MouthLeft = 11, /// Mouth right. MouthRight = 12, /// Mouth center. MouthCenter = 13, /// Nose, bottom right. NoseBottomRight = 14, /// Nose, bottom left. NoseBottomLeft = 15, /// Nose, bottom center. NoseBottomCenter = 16, /// Left eye, top boundary. LeftEyeTopBoundary = 17, /// Left eye, right corner. LeftEyeRightCorner = 18, /// Left eye, bottom boundary. LeftEyeBottomBoundary = 19, /// Left eye, left corner. LeftEyeLeftCorner = 20, /// Right eye, top boundary. RightEyeTopBoundary = 21, /// Right eye, right corner. RightEyeRightCorner = 22, /// Right eye, bottom boundary. RightEyeBottomBoundary = 23, /// Right eye, left corner. RightEyeLeftCorner = 24, /// Left eyebrow, upper midpoint. LeftEyebrowUpperMidpoint = 25, /// Right eyebrow, upper midpoint. RightEyebrowUpperMidpoint = 26, /// Left ear tragion. LeftEarTragion = 27, /// Right ear tragion. RightEarTragion = 28, /// Left eye pupil. LeftEyePupil = 29, /// Right eye pupil. RightEyePupil = 30, /// Forehead glabella. ForeheadGlabella = 31, /// Chin gnathion. ChinGnathion = 32, /// Chin left gonion. ChinLeftGonion = 33, /// Chin right gonion. ChinRightGonion = 34, } } } /// Detected entity location information. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LocationInfo { /// lat/long location coordinates. #[prost(message, optional, tag = "1")] pub lat_lng: ::core::option::Option, } /// A `Property` consists of a user-supplied name/value pair. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Property { /// Name of the property. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Value of the property. #[prost(string, tag = "2")] pub value: ::prost::alloc::string::String, /// Value of numeric properties. #[prost(uint64, tag = "3")] pub uint64_value: u64, } /// Set of detected entity features. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EntityAnnotation { /// Opaque entity ID. Some IDs may be available in /// [Google Knowledge Graph Search /// API](). #[prost(string, tag = "1")] pub mid: ::prost::alloc::string::String, /// The language code for the locale in which the entity textual /// `description` is expressed. #[prost(string, tag = "2")] pub locale: ::prost::alloc::string::String, /// Entity textual description, expressed in its `locale` language. #[prost(string, tag = "3")] pub description: ::prost::alloc::string::String, /// Overall score of the result. Range [0, 1]. #[prost(float, tag = "4")] pub score: f32, /// **Deprecated. Use `score` instead.** /// The accuracy of the entity detection in an image. /// For example, for an image in which the "Eiffel Tower" entity is detected, /// this field represents the confidence that there is a tower in the query /// image. Range [0, 1]. #[deprecated] #[prost(float, tag = "5")] pub confidence: f32, /// The relevancy of the ICA (Image Content Annotation) label to the /// image. For example, the relevancy of "tower" is likely higher to an image /// containing the detected "Eiffel Tower" than to an image containing a /// detected distant towering building, even though the confidence that /// there is a tower in each image may be the same. Range [0, 1]. #[prost(float, tag = "6")] pub topicality: f32, /// Image region to which this entity belongs. Not produced /// for `LABEL_DETECTION` features. #[prost(message, optional, tag = "7")] pub bounding_poly: ::core::option::Option, /// The location information for the detected entity. Multiple /// `LocationInfo` elements can be present because one location may /// indicate the location of the scene in the image, and another location /// may indicate the location of the place where the image was taken. /// Location information is usually present for landmarks. #[prost(message, repeated, tag = "8")] pub locations: ::prost::alloc::vec::Vec, /// Some entities may have optional user-supplied `Property` (name/value) /// fields, such a score or string that qualifies the entity. #[prost(message, repeated, tag = "9")] pub properties: ::prost::alloc::vec::Vec, } /// Set of detected objects with bounding boxes. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LocalizedObjectAnnotation { /// Object ID that should align with EntityAnnotation mid. #[prost(string, tag = "1")] pub mid: ::prost::alloc::string::String, /// The BCP-47 language code, such as "en-US" or "sr-Latn". For more /// information, see /// #[prost(string, tag = "2")] pub language_code: ::prost::alloc::string::String, /// Object name, expressed in its `language_code` language. #[prost(string, tag = "3")] pub name: ::prost::alloc::string::String, /// Score of the result. Range [0, 1]. #[prost(float, tag = "4")] pub score: f32, /// Image region to which this object belongs. This must be populated. #[prost(message, optional, tag = "5")] pub bounding_poly: ::core::option::Option, } /// Set of features pertaining to the image, computed by computer vision /// methods over safe-search verticals (for example, adult, spoof, medical, /// violence). #[derive(Clone, PartialEq, ::prost::Message)] pub struct SafeSearchAnnotation { /// Represents the adult content likelihood for the image. Adult content may /// contain elements such as nudity, pornographic images or cartoons, or /// sexual activities. #[prost(enumeration = "Likelihood", tag = "1")] pub adult: i32, /// Spoof likelihood. The likelihood that an modification /// was made to the image's canonical version to make it appear /// funny or offensive. #[prost(enumeration = "Likelihood", tag = "2")] pub spoof: i32, /// Likelihood that this is a medical image. #[prost(enumeration = "Likelihood", tag = "3")] pub medical: i32, /// Likelihood that this image contains violent content. #[prost(enumeration = "Likelihood", tag = "4")] pub violence: i32, /// Likelihood that the request image contains racy content. Racy content may /// include (but is not limited to) skimpy or sheer clothing, strategically /// covered nudity, lewd or provocative poses, or close-ups of sensitive /// body areas. #[prost(enumeration = "Likelihood", tag = "9")] pub racy: i32, } /// Rectangle determined by min and max `LatLng` pairs. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LatLongRect { /// Min lat/long pair. #[prost(message, optional, tag = "1")] pub min_lat_lng: ::core::option::Option, /// Max lat/long pair. #[prost(message, optional, tag = "2")] pub max_lat_lng: ::core::option::Option, } /// Color information consists of RGB channels, score, and the fraction of /// the image that the color occupies in the image. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ColorInfo { /// RGB components of the color. #[prost(message, optional, tag = "1")] pub color: ::core::option::Option, /// Image-specific score for this color. Value in range [0, 1]. #[prost(float, tag = "2")] pub score: f32, /// The fraction of pixels the color occupies in the image. /// Value in range [0, 1]. #[prost(float, tag = "3")] pub pixel_fraction: f32, } /// Set of dominant colors and their corresponding scores. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DominantColorsAnnotation { /// RGB color values with their score and pixel fraction. #[prost(message, repeated, tag = "1")] pub colors: ::prost::alloc::vec::Vec, } /// Stores image properties, such as dominant colors. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImageProperties { /// If present, dominant colors completed successfully. #[prost(message, optional, tag = "1")] pub dominant_colors: ::core::option::Option, } /// Single crop hint that is used to generate a new crop when serving an image. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CropHint { /// The bounding polygon for the crop region. The coordinates of the bounding /// box are in the original image's scale. #[prost(message, optional, tag = "1")] pub bounding_poly: ::core::option::Option, /// Confidence of this being a salient region. Range [0, 1]. #[prost(float, tag = "2")] pub confidence: f32, /// Fraction of importance of this salient region with respect to the original /// image. #[prost(float, tag = "3")] pub importance_fraction: f32, } /// Set of crop hints that are used to generate new crops when serving images. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CropHintsAnnotation { /// Crop hint results. #[prost(message, repeated, tag = "1")] pub crop_hints: ::prost::alloc::vec::Vec, } /// Parameters for crop hints annotation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CropHintsParams { /// Aspect ratios in floats, representing the ratio of the width to the height /// of the image. For example, if the desired aspect ratio is 4/3, the /// corresponding float value should be 1.33333. If not specified, the /// best possible crop is returned. The number of provided aspect ratios is /// limited to a maximum of 16; any aspect ratios provided after the 16th are /// ignored. #[prost(float, repeated, tag = "1")] pub aspect_ratios: ::prost::alloc::vec::Vec, } /// Parameters for web detection request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WebDetectionParams { /// Whether to include results derived from the geo information in the image. #[prost(bool, tag = "2")] pub include_geo_results: bool, } /// Parameters for text detections. This is used to control TEXT_DETECTION and /// DOCUMENT_TEXT_DETECTION features. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TextDetectionParams { /// By default, Cloud Vision API only includes confidence score for /// DOCUMENT_TEXT_DETECTION result. Set the flag to true to include confidence /// score for TEXT_DETECTION as well. #[prost(bool, tag = "9")] pub enable_text_detection_confidence_score: bool, } /// Image context and/or feature-specific parameters. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImageContext { /// Not used. #[prost(message, optional, tag = "1")] pub lat_long_rect: ::core::option::Option, /// List of languages to use for TEXT_DETECTION. In most cases, an empty value /// yields the best results since it enables automatic language detection. For /// languages based on the Latin alphabet, setting `language_hints` is not /// needed. In rare cases, when the language of the text in the image is known, /// setting a hint will help get better results (although it will be a /// significant hindrance if the hint is wrong). Text detection returns an /// error if one or more of the specified languages is not one of the /// [supported languages](). #[prost(string, repeated, tag = "2")] pub language_hints: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Parameters for crop hints annotation request. #[prost(message, optional, tag = "4")] pub crop_hints_params: ::core::option::Option, /// Parameters for face recognition. #[prost(message, optional, tag = "10")] pub face_recognition_params: ::core::option::Option, /// Parameters for product search. #[prost(message, optional, tag = "5")] pub product_search_params: ::core::option::Option, /// Parameters for web detection. #[prost(message, optional, tag = "6")] pub web_detection_params: ::core::option::Option, /// Parameters for text detection and document text detection. #[prost(message, optional, tag = "12")] pub text_detection_params: ::core::option::Option, } /// Request for performing Google Cloud Vision API tasks over a user-provided /// image, with user-requested features, and with context information. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnnotateImageRequest { /// The image to be processed. #[prost(message, optional, tag = "1")] pub image: ::core::option::Option, /// Requested features. #[prost(message, repeated, tag = "2")] pub features: ::prost::alloc::vec::Vec, /// Additional context that may accompany the image. #[prost(message, optional, tag = "3")] pub image_context: ::core::option::Option, } /// If an image was produced from a file (e.g. a PDF), this message gives /// information about the source of that image. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImageAnnotationContext { /// The URI of the file used to produce the image. #[prost(string, tag = "1")] pub uri: ::prost::alloc::string::String, /// If the file was a PDF or TIFF, this field gives the page number within /// the file used to produce the image. #[prost(int32, tag = "2")] pub page_number: i32, } /// Response to an image annotation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnnotateImageResponse { /// If present, face detection has completed successfully. #[prost(message, repeated, tag = "1")] pub face_annotations: ::prost::alloc::vec::Vec, /// If present, landmark detection has completed successfully. #[prost(message, repeated, tag = "2")] pub landmark_annotations: ::prost::alloc::vec::Vec, /// If present, logo detection has completed successfully. #[prost(message, repeated, tag = "3")] pub logo_annotations: ::prost::alloc::vec::Vec, /// If present, label detection has completed successfully. #[prost(message, repeated, tag = "4")] pub label_annotations: ::prost::alloc::vec::Vec, /// If present, localized object detection has completed successfully. /// This will be sorted descending by confidence score. #[prost(message, repeated, tag = "22")] pub localized_object_annotations: ::prost::alloc::vec::Vec, /// If present, text (OCR) detection has completed successfully. #[prost(message, repeated, tag = "5")] pub text_annotations: ::prost::alloc::vec::Vec, /// If present, text (OCR) detection or document (OCR) text detection has /// completed successfully. /// This annotation provides the structural hierarchy for the OCR detected /// text. #[prost(message, optional, tag = "12")] pub full_text_annotation: ::core::option::Option, /// If present, safe-search annotation has completed successfully. #[prost(message, optional, tag = "6")] pub safe_search_annotation: ::core::option::Option, /// If present, image properties were extracted successfully. #[prost(message, optional, tag = "8")] pub image_properties_annotation: ::core::option::Option, /// If present, crop hints have completed successfully. #[prost(message, optional, tag = "11")] pub crop_hints_annotation: ::core::option::Option, /// If present, web detection has completed successfully. #[prost(message, optional, tag = "13")] pub web_detection: ::core::option::Option, /// If present, product search has completed successfully. #[prost(message, optional, tag = "14")] pub product_search_results: ::core::option::Option, /// If set, represents the error message for the operation. /// Note that filled-in image annotations are guaranteed to be /// correct, even when `error` is set. #[prost(message, optional, tag = "9")] pub error: ::core::option::Option, /// If present, contextual information is needed to understand where this image /// comes from. #[prost(message, optional, tag = "21")] pub context: ::core::option::Option, } /// Multiple image annotation requests are batched into a single service call. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchAnnotateImagesRequest { /// Required. Individual image annotation requests for this batch. #[prost(message, repeated, tag = "1")] pub requests: ::prost::alloc::vec::Vec, } /// Response to a batch image annotation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchAnnotateImagesResponse { /// Individual responses to image annotation requests within the batch. #[prost(message, repeated, tag = "1")] pub responses: ::prost::alloc::vec::Vec, } /// A request to annotate one single file, e.g. a PDF, TIFF or GIF file. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnnotateFileRequest { /// Required. Information about the input file. #[prost(message, optional, tag = "1")] pub input_config: ::core::option::Option, /// Required. Requested features. #[prost(message, repeated, tag = "2")] pub features: ::prost::alloc::vec::Vec, /// Additional context that may accompany the image(s) in the file. #[prost(message, optional, tag = "3")] pub image_context: ::core::option::Option, /// Pages of the file to perform image annotation. /// /// Pages starts from 1, we assume the first page of the file is page 1. /// At most 5 pages are supported per request. Pages can be negative. /// /// Page 1 means the first page. /// Page 2 means the second page. /// Page -1 means the last page. /// Page -2 means the second to the last page. /// /// If the file is GIF instead of PDF or TIFF, page refers to GIF frames. /// /// If this field is empty, by default the service performs image annotation /// for the first 5 pages of the file. #[prost(int32, repeated, tag = "4")] pub pages: ::prost::alloc::vec::Vec, } /// Response to a single file annotation request. A file may contain one or more /// images, which individually have their own responses. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnnotateFileResponse { /// Information about the file for which this response is generated. #[prost(message, optional, tag = "1")] pub input_config: ::core::option::Option, /// Individual responses to images found within the file. This field will be /// empty if the `error` field is set. #[prost(message, repeated, tag = "2")] pub responses: ::prost::alloc::vec::Vec, /// This field gives the total number of pages in the file. #[prost(int32, tag = "3")] pub total_pages: i32, /// If set, represents the error message for the failed request. The /// `responses` field will not be set in this case. #[prost(message, optional, tag = "4")] pub error: ::core::option::Option, } /// A list of requests to annotate files using the BatchAnnotateFiles API. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchAnnotateFilesRequest { /// Required. The list of file annotation requests. Right now we support only /// one AnnotateFileRequest in BatchAnnotateFilesRequest. #[prost(message, repeated, tag = "1")] pub requests: ::prost::alloc::vec::Vec, } /// A list of file annotation responses. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BatchAnnotateFilesResponse { /// The list of file annotation responses, each response corresponding to each /// AnnotateFileRequest in BatchAnnotateFilesRequest. #[prost(message, repeated, tag = "1")] pub responses: ::prost::alloc::vec::Vec, } /// An offline file annotation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AsyncAnnotateFileRequest { /// Required. Information about the input file. #[prost(message, optional, tag = "1")] pub input_config: ::core::option::Option, /// Required. Requested features. #[prost(message, repeated, tag = "2")] pub features: ::prost::alloc::vec::Vec, /// Additional context that may accompany the image(s) in the file. #[prost(message, optional, tag = "3")] pub image_context: ::core::option::Option, /// Required. The desired output location and metadata (e.g. format). #[prost(message, optional, tag = "4")] pub output_config: ::core::option::Option, } /// The response for a single offline file annotation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AsyncAnnotateFileResponse { /// The output location and metadata from AsyncAnnotateFileRequest. #[prost(message, optional, tag = "1")] pub output_config: ::core::option::Option, } /// Request for async image annotation for a list of images. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AsyncBatchAnnotateImagesRequest { /// Required. Individual image annotation requests for this batch. #[prost(message, repeated, tag = "1")] pub requests: ::prost::alloc::vec::Vec, /// Required. The desired output location and metadata (e.g. format). #[prost(message, optional, tag = "2")] pub output_config: ::core::option::Option, } /// Response to an async batch image annotation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AsyncBatchAnnotateImagesResponse { /// The output location and metadata from AsyncBatchAnnotateImagesRequest. #[prost(message, optional, tag = "1")] pub output_config: ::core::option::Option, } /// Multiple async file annotation requests are batched into a single service /// call. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AsyncBatchAnnotateFilesRequest { /// Required. Individual async file annotation requests for this batch. #[prost(message, repeated, tag = "1")] pub requests: ::prost::alloc::vec::Vec, } /// Response to an async batch file annotation request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AsyncBatchAnnotateFilesResponse { /// The list of file annotation responses, one for each request in /// AsyncBatchAnnotateFilesRequest. #[prost(message, repeated, tag = "1")] pub responses: ::prost::alloc::vec::Vec, } /// The desired input location and metadata. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InputConfig { /// The Google Cloud Storage location to read the input from. #[prost(message, optional, tag = "1")] pub gcs_source: ::core::option::Option, /// File content, represented as a stream of bytes. /// Note: As with all `bytes` fields, protobuffers use a pure binary /// representation, whereas JSON representations use base64. /// /// Currently, this field only works for BatchAnnotateFiles requests. It does /// not work for AsyncBatchAnnotateFiles requests. #[prost(bytes = "vec", tag = "3")] pub content: ::prost::alloc::vec::Vec, /// The type of the file. Currently only "application/pdf", "image/tiff" and /// "image/gif" are supported. Wildcards are not supported. #[prost(string, tag = "2")] pub mime_type: ::prost::alloc::string::String, } /// The desired output location and metadata. #[derive(Clone, PartialEq, ::prost::Message)] pub struct OutputConfig { /// The Google Cloud Storage location to write the output(s) to. #[prost(message, optional, tag = "1")] pub gcs_destination: ::core::option::Option, /// The max number of response protos to put into each output JSON file on /// Google Cloud Storage. /// The valid range is [1, 100]. If not specified, the default value is 20. /// /// For example, for one pdf file with 100 pages, 100 response protos will /// be generated. If `batch_size` = 20, then 5 json files each /// containing 20 response protos will be written under the prefix /// `gcs_destination`.`uri`. /// /// Currently, batch_size only applies to GcsDestination, with potential future /// support for other output configurations. #[prost(int32, tag = "2")] pub batch_size: i32, } /// The Google Cloud Storage location where the input will be read from. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GcsSource { /// Google Cloud Storage URI for the input file. This must only be a /// Google Cloud Storage object. Wildcards are not currently supported. #[prost(string, tag = "1")] pub uri: ::prost::alloc::string::String, } /// The Google Cloud Storage location where the output will be written to. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GcsDestination { /// Google Cloud Storage URI prefix where the results will be stored. Results /// will be in JSON format and preceded by its corresponding input URI prefix. /// This field can either represent a gcs file prefix or gcs directory. In /// either case, the uri should be unique because in order to get all of the /// output files, you will need to do a wildcard gcs search on the uri prefix /// you provide. /// /// Examples: /// /// * File Prefix: gs://bucket-name/here/filenameprefix The output files /// will be created in gs://bucket-name/here/ and the names of the /// output files will begin with "filenameprefix". /// /// * Directory Prefix: gs://bucket-name/some/location/ The output files /// will be created in gs://bucket-name/some/location/ and the names of the /// output files could be anything because there was no filename prefix /// specified. /// /// If multiple outputs, each response is still AnnotateFileResponse, each of /// which contains some subset of the full list of AnnotateImageResponse. /// Multiple outputs can happen if, for example, the output JSON is too large /// and overflows into multiple sharded files. #[prost(string, tag = "1")] pub uri: ::prost::alloc::string::String, } /// Contains metadata for the BatchAnnotateImages operation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct OperationMetadata { /// Current state of the batch operation. #[prost(enumeration = "operation_metadata::State", tag = "1")] pub state: i32, /// The time when the batch request was received. #[prost(message, optional, tag = "5")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// The time when the operation result was last updated. #[prost(message, optional, tag = "6")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, } /// Nested message and enum types in `OperationMetadata`. pub mod operation_metadata { /// Batch operation states. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// Invalid. Unspecified = 0, /// Request is received. Created = 1, /// Request is actively being processed. Running = 2, /// The batch processing is done. Done = 3, /// The batch processing was cancelled. Cancelled = 4, } } /// A bucketized representation of likelihood, which is intended to give clients /// highly stable results across model upgrades. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Likelihood { /// Unknown likelihood. Unknown = 0, /// It is very unlikely. VeryUnlikely = 1, /// It is unlikely. Unlikely = 2, /// It is possible. Possible = 3, /// It is likely. Likely = 4, /// It is very likely. VeryLikely = 5, } #[doc = r" Generated client implementations."] pub mod image_annotator_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " Service that performs Google Cloud Vision API detection tasks over client"] #[doc = " images, such as face, landmark, logo, label, and text detection. The"] #[doc = " ImageAnnotator service returns detected entities from the images."] #[derive(Debug, Clone)] pub struct ImageAnnotatorClient { inner: tonic::client::Grpc, } impl ImageAnnotatorClient 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, ) -> ImageAnnotatorClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { ImageAnnotatorClient::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 = " Run image detection and annotation for a batch of images."] pub async fn batch_annotate_images( &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.vision.v1p4beta1.ImageAnnotator/BatchAnnotateImages", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Service that performs image detection and annotation for a batch of files."] #[doc = " Now only \"application/pdf\", \"image/tiff\" and \"image/gif\" are supported."] #[doc = ""] #[doc = " This service will extract at most 5 (customers can specify which 5 in"] #[doc = " AnnotateFileRequest.pages) frames (gif) or pages (pdf or tiff) from each"] #[doc = " file provided and perform detection and annotation for each image"] #[doc = " extracted."] pub async fn batch_annotate_files( &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.vision.v1p4beta1.ImageAnnotator/BatchAnnotateFiles", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Run asynchronous image detection and annotation for a list of images."] #[doc = ""] #[doc = " Progress and results can be retrieved through the"] #[doc = " `google.longrunning.Operations` interface."] #[doc = " `Operation.metadata` contains `OperationMetadata` (metadata)."] #[doc = " `Operation.response` contains `AsyncBatchAnnotateImagesResponse` (results)."] #[doc = ""] #[doc = " This service will write image annotation outputs to json files in customer"] #[doc = " GCS bucket, each json file containing BatchAnnotateImagesResponse proto."] pub async fn async_batch_annotate_images( &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.vision.v1p4beta1.ImageAnnotator/AsyncBatchAnnotateImages", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Run asynchronous image detection and annotation for a list of generic"] #[doc = " files, such as PDF files, which may contain multiple pages and multiple"] #[doc = " images per page. Progress and results can be retrieved through the"] #[doc = " `google.longrunning.Operations` interface."] #[doc = " `Operation.metadata` contains `OperationMetadata` (metadata)."] #[doc = " `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results)."] pub async fn async_batch_annotate_files( &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.vision.v1p4beta1.ImageAnnotator/AsyncBatchAnnotateFiles", ); self.inner.unary(request.into_request(), path, codec).await } } }