#[derive(Clone, Copy, Debug, strum::EnumString)]
pub enum Endpoint {
    CnHangzhou,
}

impl Endpoint {
    pub fn name(self) -> &'static str {
        match self {
            Endpoint::CnHangzhou => "cn-hangzhou",
        }
    }
}

impl From<Endpoint> for &'static str {
    fn from(ep: Endpoint) -> Self {
        match ep {
            Endpoint::CnHangzhou => "ocr-api.cn-hangzhou.aliyuncs.com",
        }
    }
}

mod sealed {
    /// prevent Request type used with Connection of other mod.
    pub trait Bound {}
}

#[derive(Clone)]
pub struct Connection(crate::common::Connection<crate::auth::Acs3HmacSha256>);

impl Connection {
    pub fn new(endpoint: Endpoint, app_key_secret: crate::v3::AccessKeySecret) -> Self {
        Self(crate::common::Connection::new(
            crate::auth::Acs3HmacSha256(app_key_secret),
            "2021-07-07",
            endpoint.into(),
        ))
    }

    pub fn with_client(
        endpoint: Endpoint,
        app_key_secret: crate::v3::AccessKeySecret,
        client: reqwest::Client,
    ) -> Self {
        Self(crate::common::Connection::with_client(
            crate::auth::Acs3HmacSha256(app_key_secret),
            "2021-07-07",
            endpoint.into(),
            client,
        ))
    }

    fn call<R: crate::Request + sealed::Bound>(
        &self,
        req: R,
    ) -> impl std::future::Future<
        Output = crate::Result<<R::ResponseWrap as crate::IntoResponse>::Response>,
    > + Send {
        self.0.call(req)
    }
}

impl Connection {
    /// # OCR统一识别
    ///
    /// OCR统一识别接口支持识别多种图片类型，包括通用文字、个人卡证、发票等。您只需要通过Type参数指定图片类型，无须更换接口。
    ///
    /// #### 如何使用本接口
    /// | 步骤 | 概述                                                                                                                                                                                                                                                                                                                                                                                                                                      |
    /// | ---- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    /// | 1    | 开通[OCR 统一识别](https://common-buy.aliyun.com/?commodityCode=ocr_unity_public_cn)服务。 开通此API后会赠送免费额度，可使用免费额度测试。                                                                                                                                                                                                                                                                                                                                      |
    /// | 2    | 购买[OCR 共享资源包](https://common-buy.aliyun.com/?spm=5176.23043878.0.0.5f3d1287hpm7ZT&commodityCode=ocr_share_dp_cn)。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。                                                                                                                                           |
    /// | 3    | 可以参照[调试页面](https://api.aliyun.com/api/ocr-api/2021-07-07/RecognizeAllText?sdkStyle=dara)提供的代码示例完成 API 接入开发。接入完成后，调用 API 获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对 RAM 账号进行授权。创建 RAM 用户的具体操作，请参考：[创建 RAM 用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为 RAM 用户授权。](https://help.aliyun.com/document_detail/116146.html) |
    ///
    /// #### 重要提示
    ///
    /// | 类型     | 概述                                                                                                                                                                      |
    /// | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    /// | 图片格式 | <ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP、PDF。</li></ul>                                        |
    /// | 图片尺寸 | <ul> <li> 图片长宽需要大于 15 像素，小于 8192 像素。</li> <li>长宽比需要小于 50。</li> <li>如需达到较好识别效果，建议长宽均大于 500px。</li> </ul>                        |
    /// | 图片大小 | <ul> <li> 图片二进制文件不能超过 10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于 1.5M 图片进行识别，且通过传图片 URL 的方式调用接口。</li> </ul>                |
    /// | 其他提示 | <ul> <li>请保证整张图片内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul> |
    ///
    /// # Error Codes
    /// - `invalidInputParameter`: %s
    /// - `InvalidCountry`: Specified parameter Country is not valid.///
    /// # Extra Info
    /// #### 您可以参考下面的示例调用统一API接口
    /// * 通过图片URL请求接口Java示例
    /// ```ignore
    /// package demo;
    /// import com.aliyun.ocr_api20210707.Client;
    /// import com.aliyun.ocr_api20210707.models.*;
    /// import com.aliyun.tea.TeaException;
    /// import com.aliyun.teaopenapi.models.Config;
    /// import com.google.gson.Gson;
    /// public class Demo {
    ///     public static void main(String[] args) throws Exception {
    ///         final String endpoint = "ocr-api.cn-hangzhou.aliyuncs.com";
    ///         final String accessKeyID = "您的AccessKeyID";
    ///         final String accessKeySecret = "您的AccessKeySecret";
    ///         final String imageUrl = "https://example.png";
    ///         final Config config = new Config().setEndpoint(endpoint).setAccessKeyId(accessKeyID).setAccessKeySecret(accessKeySecret);
    ///         Client client = new Client(config);
    ///         RecognizeAllTextRequest request = new RecognizeAllTextRequest()
    ///                 .setType("Advanced")        // 指定Type（此参数为必填参数）
    ///                 .setUrl(imageUrl)           // 图片url
    ///                 .setOutputOricoord(true);   // 设置返回原图坐标。您可以设置更多二级参数。
    ///         // 您也可以在 request 中指定更多三级参数。例如对于 Type=Advanced，可以指定 OutputCharInfo=true（输出单字信息）
    ///         RecognizeAllTextRequest.RecognizeAllTextRequestAdvancedConfig advancedConfig = new RecognizeAllTextRequest.RecognizeAllTextRequestAdvancedConfig()
    ///             .setOutputCharInfo(true);
    ///         request.setAdvancedConfig(advancedConfig);
    ///         try {
    ///             RecognizeAllTextResponse response = client.recognizeAllText(request);
    ///             System.out.println(new Gson().toJson(response.getBody().getData().toMap()));
    ///         } catch (TeaException e) {
    ///             System.out.println(e.getStatusCode());
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// * 通过上传本地图片请求接口Java示例
    /// ```ignore
    /// package demo;
    /// import com.aliyun.ocr_api20210707.Client;
    /// import com.aliyun.ocr_api20210707.models.*;
    /// import com.aliyun.tea.TeaException;
    /// import com.aliyun.teaopenapi.models.Config;
    /// import com.google.gson.Gson;
    /// public class Demo {
    ///     public static void main(String[] args) throws Exception {
    ///         final String endpoint = "ocr-api.cn-hangzhou.aliyuncs.com";
    ///         final String accessKeyID = "您的AccessKeyID";
    ///         final String accessKeySecret = "您的AccessKeySecret";
    ///         final Config config = new Config().setEndpoint(endpoint).setAccessKeyId(accessKeyID).setAccessKeySecret(accessKeySecret);
    ///         final String localImageFileName = "~/example.png"; // 本地图片路径
    ///         Client client = new Client(config);
    ///         try (InputStream imageStream = new FileInputStream(localImageFileName)) {
    ///             RecognizeAllTextRequest request = new RecognizeAllTextRequest()
    ///                     .setType("Advanced")        // 指定Type（此参数为必填参数）
    ///                     .setBody(imageStream)       // 指定本地图片路径
    ///                     .setOutputOricoord(true);   // 设置返回原图坐标。您可以设置更多二级参数。
    ///             // 您也可以在 request 中指定更多参数。例如对于 Type=Advanced，可以指定 OutputCharInfo=true（输出单字信息）
    ///             RecognizeAllTextRequest.RecognizeAllTextRequestAdvancedConfig advancedConfig = new RecognizeAllTextRequest.RecognizeAllTextRequestAdvancedConfig()
    ///                     .setOutputCharInfo(true);
    ///             request.setAdvancedConfig(advancedConfig);
    ///             RecognizeAllTextResponse response = client.recognizeAllText(request);
    ///             System.out.println(new Gson().toJson(response.getBody().getData().toMap()));
    ///         } catch (TeaException e) {
    ///             System.out.println(e.getStatusCode());
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_all_text(
        &self,
        req: RecognizeAllText,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeAllTextResponse>> + Send {
        self.call(req)
    }

    /// # 通用票证抽取
    ///
    /// 通用票证抽取结合读光OCR和通义千问大模型的能力，针对OCR不支持的长尾票据，提供关键KV信息抽取，例如名称、地址、开票日期等关键字段结构化识别输出。
    ///
    /// #### 如何使用本接口
    ///
    /// | 步骤 | 概述                                                                                                                                                                                                                                                                                                                                                                                                                                      |
    /// | ---- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    /// | 1    | 开通 [OCR 统一识别](https://common-buy.aliyun.com/?commodityCode=ocr_unity_public_cn) 服务。本接口在公测阶段，是免费接口，开通后即可调用。
    /// | 3    | 可以参照[调试页面](https://api.aliyun.com/api/ocr-api/2021-07-07/RecognizeGeneralStructure?sdkStyle=dara) 提供的代码示例完成 API 接入开发。接入完成后，调用 API 获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对 RAM 账号进行授权。创建 RAM 用户的具体操作，请参考：[创建 RAM 用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为 RAM 用户授权。](https://help.aliyun.com/document_detail/116146.html) |
    ///
    /// #### 重要提示
    ///
    /// | 类型     | 概述                                                                                                                                                                      |
    /// | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    /// | 图片格式 | <ul> <li>本接口支持：PNG、JPG、JPEG、PDF、BMP、GIF、TIFF、WebP。</li></ul>                                        |
    /// | 图片尺寸 | <ul> <li> 图片长宽需要大于 15 像素，小于 8192 像素。</li> <li>长宽比需要小于 50。</li> <li>如需达到较好识别效果，建议长宽均大于 500px。</li> </ul>                        |
    /// | 图片大小 | <ul> <li> 图片二进制文件不能超过 10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于 1.5M 图片进行识别，且通过传图片 URL 的方式调用接口。</li> </ul>                |
    /// | 其他提示 | <ul> <li>请保证整张图片内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li><li> PDF类型文件仅识别第一页。 </li> </ul> |
    /// ---
    ///
    /// # Error Codes
    /// - `ExceededKeyNumber`: Too many keys, please try again with fewer keys.
    /// - `DataInspectionFailed`: Input or output data may contain inappropriate content.
    /// - `LLMTimeout`: Large language model timeout, please try again with fewer keys.///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_general_structure(
        &self,
        req: RecognizeGeneralStructure,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeGeneralStructureResponse>> + Send
    {
        self.call(req)
    }

    /// # 全文识别高精版
    ///
    /// 支持多格式版面、复杂文档背景和光照环境的精准识别，可实现印章擦除后识别，支持低置信度过滤、图案检测等高阶功能。
    ///
    /// #### 本接口适用场景
    /// * 阿里云全文识别高精版，是阿里云官方自研OCR文字识别产品，智能识别图片所包含的全部字段，集表格识别、旋转识别、生僻字识别等多功能为一体，提供高性价比的多场景文字识别体验。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01JW5Amf1TfpKdxvNhB_!!6000000002410-2-tps-1105-549.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多功能集结|集表格识别、旋转识别、生僻字识别等多功能为一体。|
    /// |抗干扰|支持多格式版面、复杂文档背景和光照环境的精准识别。|
    /// |自动排异|对有印章、手印的文档，可实现印章擦除后识别。|
    /// |高阶能力|支持覆盖文字编辑、低置信度过滤、图案检测。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [通用文字识别](https://common-buy.aliyun.com?commodityCode=ocr_general_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=universal&subtype=general#intro)免费体验本功能识别效果。|
    /// |2|购买[全文识别高精版资源包](https://common-buy.aliyun.com/?commodityCode=ocr_general_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_general_dp_cn_20211103172431_0719%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeAdvanced?lang=JAVA&sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_advanced(
        &self,
        req: RecognizeAdvanced,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeAdvancedResponse>> + Send {
        self.call(req)
    }

    /// # 通用手写体识别
    ///
    /// 支持中文手写体、英文手写体、数字手写体等各种复杂场景的手写文字识别。
    ///
    /// #### 本接口适用场景
    /// * 阿里云通用手写体识别，是阿里云官方自研OCR文字识别产品，适用于获取手写体书面形式的文字场景，适用于各类手写笔记、板书等。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1xvaLcggP7K4jSZFqXXamhVXa-1600-920.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多文字形式|支持中文手写体、英文手写体、数字手写体。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [通用文字识别](https://common-buy.aliyun.com?commodityCode=ocr_general_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=universal&subtype=shouxie#intro)免费体验本功能识别效果。|
    /// |2|购买[通用手写体识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_general_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_general_dp_cn_20211103172431_0249%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeHandwriting?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场手写体识别。](https://market.aliyun.com/apimarket/detail/cmapi00040832) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_handwriting(
        &self,
        req: RecognizeHandwriting,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeHandwritingResponse>> + Send {
        self.call(req)
    }

    /// # 电商图片文字识别
    ///
    /// 针对电商商品宣传图片、社区贴吧图片、网络UGC图片等网络场景下图片字符快速精准识别。
    ///
    /// #### 本接口适用场景
    /// * 阿里云电商图片文字识别，是阿里云官方自研OCR文字识别产品，支持电商商品宣传图片、社区贴吧图片、网络UGC图片识别，针对电商海量图片内容核查就场景进行特定优化，只输出文字块内容及坐标，极大提升识别效率。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN01beY6FP20nVIAEwIiL_!!6000000006894-0-tps-850-443.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |多网络场景|电商商品宣传图片、社区贴吧图片、网络UGC图片等网络场景识别文字。|
    /// |适用场合|适用于违规广告识别、信息审核管理和网络安全治理等场景。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [通用文字识别](https://common-buy.aliyun.com?commodityCode=ocr_general_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=universal&subtype=ecommerce#intro)免费体验本功能识别效果。|
    /// |2|购买[电商图片文字识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_general_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_general_dp_cn_20211103172431_0503%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeBasic?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_basic(
        &self,
        req: RecognizeBasic,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeBasicResponse>> + Send {
        self.call(req)
    }

    /// # 通用文字识别
    ///
    /// 适用于非结构化文字识别，支持返回文字内容和位置坐标信息。
    ///
    /// #### 本接口适用场景
    /// * 阿里云通用文字识别，是阿里云官方自研OCR文字识别产品，适用于各类常见文档图片或文档扫描件中的文字信息按照文档原有的格式智能识别文字并结构化输出识别结果。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i3/O1CN01g9tMm71eQDRRu7U3C_!!6000000003865-2-tps-899-243.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |全字段识别|结构化识别图片上所包含的全字段，并返回JSON。|
    /// |图像增强|默认支持图像增强，包括图像畸变自动矫正、模糊图片自动增强等能力。|
    /// |高精度高性能|超高精度及性能；识别准确率位于行业前列，识别速度显著高于国内其他OCR云服务。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [通用文字识别](https://common-buy.aliyun.com?commodityCode=ocr_general_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=universal&subtype=general_text#intro)免费体验本功能识别效果。|
    /// |2|购买[通用文字识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_general_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_general_dp_cn_20211103172431_0908%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeGeneral?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_general(
        &self,
        req: RecognizeGeneral,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeGeneralResponse>> + Send {
        self.call(req)
    }

    /// # 表格识别
    ///
    /// 支持对有线表格、条纹表格、无线表格进行有效识别。
    ///
    /// #### 本接口适用场景
    /// * 阿里云表格识别，是阿里云官方自研OCR文字识别产品，支持对多种表格格式（有线表格、条纹表格、无线表格）进行智能文字识别并结构化输出识别结果。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://help-static-aliyun-doc.aliyuncs.com/assets/img/zh-CN/6884068261/p303185.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多格式|支持有线表格、条纹表格、无线表格、手写表格识别。|
    /// |全字段识别|智能识别图片上的表格所包含的全部字段。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |置信度对比|对低置信度文字进行标红处理，便于二次确认。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [通用文字识别](https://common-buy.aliyun.com?commodityCode=ocr_general_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=universal&subtype=table#intro)免费体验本功能识别效果。|
    /// |2|购买[表格识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_general_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_general_dp_cn_20211103172431_0075%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeTableOcr?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// 注：PDF文件格式的表格解析请点击[表格智能解析](https://help.aliyun.com/document_detail/450742.html)快速了解
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_table_ocr(
        &self,
        req: RecognizeTableOcr,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeTableOcrResponse>> + Send {
        self.call(req)
    }

    /// # 防疫健康码识别
    ///
    /// 包括全国主要省市健康码，支持健康码图片的姓名、日期、时间、颜色、备注信息等主要字段的识别结果输出。
    ///
    /// #### 本接口适用场景
    /// * 阿里云防疫健康码识别，是阿里云官方自研OCR文字识别产品，适用于获取健康码上的健康码颜色、姓名、日期等关键信息的场景。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://help-static-aliyun-doc.aliyuncs.com/assets/img/zh-CN/7365590561/p433785.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |全字段识别|智能识别营业执照上所包含的全部字段。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [通用文字识别](https://common-buy.aliyun.com?commodityCode=ocr_general_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=universal&subtype=health_code#intro)免费体验本功能识别效果。|
    /// |2|购买[防疫健康码识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_general_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_general_dp_cn_20220419111546_0636%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeHealthCode?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|。
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_health_code(
        &self,
        req: RecognizeHealthCode,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeHealthCodeResponse>> + Send {
        self.call(req)
    }

    /// # 文档结构化识别
    ///
    /// 对文档信息进行结构化识别，并提供元素平铺和层级树两种视角的版面信息输出。能够将文档中的文字元素（单字、文字块、行等）和相应的版面格式（标题、段落、表格）抽离并按顺序输出。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_document_structure(
        &self,
        req: RecognizeDocumentStructure,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeDocumentStructureResponse>> + Send
    {
        self.call(req)
    }

    /// # 身份证识别
    ///
    /// 支持二代身份证正反面，包括姓名、性别、民族、地址、出生日期、身份证号、签发机关、有效期限等字段的结构化识别。支持身份证质量检测，是否翻拍，是否是复印件，完整度评分，整体质量分数、篡改指数及人脸位置检测。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云身份证文字识别，是阿里云官方自研OCR文字识别产品，用于对中国大陆身份证（含临时身份证）正反面图片进行智能文字识别并结构化输出识别结果。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i3/O1CN01VMB4xL1kWWl9GqGNt_!!6000000004691-0-tps-1071-532.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多类型覆盖|支持自动区分正反面、支持少数民族版式识别、临时身份证识别、生僻字识别、反光实拍、劣质图像识别。<img width=1000/>|
    /// |风险检测|支持证件风险检测预警能力，包括智能判断图片完整度、复印件检测、翻拍检测、质量分等。|
    /// |人像检测|支持图像检测功能，可定位身份证中的人像图案并返回坐标。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=idcard#intro)免费体验本功能识别效果。|
    /// |2|购买[身份证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20211018150333_0014%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](~~295347~~)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeIdcard?lang=SWIFT&sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](~~93720~~)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](~~116146~~)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |国家与语言| <ul> <li>本接口只支持中国大陆身份证。</li></ul> |
    /// |其他提示|<ul> <li>请保证整张身份证内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [身份证混贴识别。](https://market.aliyun.com/products/57124001/cmapi00042846.html?#sku=yuncode3684600001) </li> <li> [国际身份证识别。](~~455939~~) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_idcard(
        &self,
        req: RecognizeIdcard,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeIdcardResponse>> + Send {
        self.call(req)
    }

    /// # 国际护照识别
    ///
    /// 可对美国、法国、英国、日本、韩国等世界多个主要国家和地区护照提供识别服务，支持字段包括国籍、护照号码、出生日期、姓名等。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云国际护照识别，是阿里云官方自研OCR文字识别产品，适用于出入境审查、国内外身份核验等各种需要提取护照信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN01A0sPpE1ZzPvVTa6QV_!!6000000003265-2-tps-2482-1193.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多国护照|对美国、法国、英国、日本、韩国等多国和地区护照提供识别服务。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=passport#intro)免费体验本功能识别效果。|
    /// |2|购买[国际护照识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20211018150333_0624%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizePassport?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场护照识别。](https://market.aliyun.com/products/57124001/cmapi016682.html?spm=a2c4g.11186623.0.0.47e98a21paGIxa&innerSource=search#sku=yuncode1068200007) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_passport(
        &self,
        req: RecognizePassport,
    ) -> impl std::future::Future<Output = crate::Result<RecognizePassportResponse>> + Send {
        self.call(req)
    }

    /// # 户口本识别
    ///
    /// 可结构化识别户口常住人口登记卡页面及户主页的内容，有效识别户口本上的相关户籍证明信息。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云户口本识别，是阿里云官方自研OCR文字识别产品，可用于识别户口本户主页的户主姓名、住址、户号等字段。也适用于识别户口本常住人口页的出生日期、出生地、姓名、民族等信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN01XgQQf11PBoxYZP19J_!!6000000001803-2-tps-2458-1318.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=household#intro)免费体验本功能识别效果。|
    /// |2|购买 [个人证照识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20211018150333_0555%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeHousehold?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_household(
        &self,
        req: RecognizeHousehold,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeHouseholdResponse>> + Send {
        self.call(req)
    }

    /// # 不动产权证识别
    ///
    /// 可准确识别不动产证中的各项关键信息，包括户主信息、房屋地址、面积大小、土地权利类型等，适用于全国各地的不同房产证识别。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云不动产权证识别，是阿里云官方自研OCR文字识别产品，适用于识别不动产权证和房产证上的关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1Nk0DOpP7gK0jSZFjXXc5aXXa-1600-920.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |适用范围广|适用于全国各地的不同不动产权证和房产证识别。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=estate_cert#intro)免费体验本功能识别效果。|
    /// |2|购买[不动产权证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20211018150333_0807%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEstateCertification?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场不动产权证识别。](https://market.aliyun.com/products/57124001/cmapi032590.html?spm=a2c4g.11186623.0.0.53898a21nnCeEE#sku=yuncode2659000001) </li>  </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_estate_certification(
        &self,
        req: RecognizeEstateCertification,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEstateCertificationResponse>> + Send
    {
        self.call(req)
    }

    /// # 银行卡识别
    ///
    /// 可精准识别各类银行卡中的银行卡卡号和有效期，且支持横卡、竖卡及银行卡任意角度偏斜情况的识别与提取，支持中国内地大多数银行，以及各种位数、凸字卡面、平面卡面等的识别。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云银行卡识别，是阿里云官方自研OCR文字识别产品，适用于获取银行卡上的卡号、日期、银行名称等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1gbfaN7L0gK0jSZFAXXcA9pXa-1600-800.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多银行|支持中国银行、中国工商银行、交通银行、邮政银行等多家银行。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |多卡面类型|支持各种位数、凸字卡面、平面卡面的识别。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=bank_card#intro)免费体验本功能识别效果。|
    /// |2|购买 [银行卡识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20211018150333_0139%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeBankCard?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场银行卡识别。](https://market.aliyun.com/products/57124001/cmapi016870.html?spm=a2c4g.11186623.0.0.47e98a21uyjeUi&innerSource=search#sku=yuncode1087000000) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_bank_card(
        &self,
        req: RecognizeBankCard,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeBankCardResponse>> + Send {
        self.call(req)
    }

    /// # 出生证明识别
    ///
    /// 可准确识别出生证明中的各项关键信息，包括出生日期、出生体重、出生地点等。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云出生证明识别，是阿里云官方自研OCR文字识别产品，适用于识别出生证明所包含的新生儿姓名、性别、出生日期、出生地点等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN01NGKqgA1DoxKux5pBP_!!6000000000264-0-tps-1046-705.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图片格式|支持PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=birth_certification#intro)免费体验本功能识别效果。|
    /// |2|购买[出生证明识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20211018150333_0645%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeBirthCertification?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li></ul>|
    /// |相关能力|<ul> <li> [云市场出生证明识别。](https://market.aliyun.com/products/57124001/cmapi00043620.html?spm=a2c4g.11186623.0.0.47e98a21Sz0eAq#sku=yuncode3762000001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_birth_certification(
        &self,
        req: RecognizeBirthCertification,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeBirthCertificationResponse>> + Send
    {
        self.call(req)
    }

    /// # 中国护照识别
    ///
    /// 支持中国人民共和国护照的结构化内容检测识别功能，支持中国内地、中国香港、中国澳门和中国台湾地区的护照识别，识别内容包括出生地、出生日期、国籍、性别、护照号码、有效期至、签发国、签发地等字段。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_chinese_passport(
        &self,
        req: RecognizeChinesePassport,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeChinesePassportResponse>> + Send
    {
        self.call(req)
    }

    /// # 来往大陆（内地）通行证识别
    ///
    /// 可准确识别通行证中的各项关键信息，包括姓名、出生日期、证件号码等。包括港澳居民来往大陆通行证以及台湾居民来往大陆通行证。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云来往大陆通行证识别，精准识别通行证中所包含的中英文姓名、出生日期、有效期限、签发地点、证件号码等信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例（仅支持正面识别）
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN01VpucoK1PtmovU859J_!!6000000001899-0-tps-928-626.jpg" width="50%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=mainland_card#intro)免费体验本功能识别效果。|
    /// |2|购买 [个人证照识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20211222165053_0134%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeExitEntryPermitToMainland?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |识别范围|<ul> <li> 本接口只支持正面识别，背面不支持。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_exit_entry_permit_to_mainland(
        &self,
        req: RecognizeExitEntryPermitToMainland,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeExitEntryPermitToMainlandResponse>>
    + Send {
        self.call(req)
    }

    /// # 往来港澳台通行证识别
    ///
    /// 支持通行证中的各项关键信息，姓名、出生日期、证件号码等字段的准确识别。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_exit_entry_permit_to_hk(
        &self,
        req: RecognizeExitEntryPermitToHK,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeExitEntryPermitToHKResponse>> + Send
    {
        self.call(req)
    }

    /// # 中国香港身份证识别
    ///
    /// 支持香港永久性居民身份证和香港居民身份证两种类型的证件识别，已支持全字段识别，包括中文姓名（如有）、英文姓名、中文姓名电码（如有）、出生日期、性别、符号标记、身份证号码等。
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。|
    /// |2|购买[中国香港身份证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20230323152059_0554%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeHKIdcard?sdkStyle=dara&tab=DEMO&lang=JAVA)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |国家与语言| <ul> <li>本接口只支持中国香港身份证。</li></ul> |
    /// |其他提示|<ul> <li>请保证整张身份证内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [国际身份证识别。](https://help.aliyun.com/document_detail/455939.html) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_hk_idcard(
        &self,
        req: RecognizeHKIdcard,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeHKIdcardResponse>> + Send {
        self.call(req)
    }

    /// # 社保卡识别
    ///
    /// 支持全字段识别，包括标题、姓名、社会保障号码、社会保障卡号、银行账号、发卡日期等。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云社保卡识别，是阿里云官方自研OCR文字识别产品，适用于识别社会保障卡中所包含的标题、姓名、社保卡号码、卡号、发卡日期等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01lTV8Qu1jeU1ycPA30_!!6000000004573-2-tps-820-272.png" width="60%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达97%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=social_security_card#intro)免费体验本功能识别效果。|
    /// |2|购买[个人证照识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20220507144415_0128%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeSocialSecurityCardVersionII?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。</li> </ul> |
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_social_security_card_version_ii(
        &self,
        req: RecognizeSocialSecurityCardVersionII,
    ) -> impl std::future::Future<
        Output = crate::Result<RecognizeSocialSecurityCardVersionIIResponse>,
    > + Send {
        self.call(req)
    }

    /// # 国际身份证识别
    ///
    /// 可对国外身份证件进行结构化识别，目前支持越南、韩国、印度、孟加拉居民身份证，可识别字段包括姓名、出生日期、证件号码等。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云国际身份证识别，是阿里云官方自研OCR文字识别产品，适用于出入境审查、国内外身份核验等各种需要提取身份证信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN01DvhDz81Y8uxtjp3ER_!!6000000003015-0-tps-1071-532.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多国身份证|对越南、韩国、印度、孟加拉居民身份证提供识别服务|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [个人证照识别](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=standard&subtype=idcard#intro)免费体验本功能识别效果。|
    /// |2|购买[国际身份证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_personalcard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_personalcard_dp_cn_20220829103503_0482%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeInternationalIdcard?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP、OFD、PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>请保证整张身份证内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Error Codes
    /// - `illegalCountryName`: the country name is not supported.///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_international_idcard(
        &self,
        req: RecognizeInternationalIdcard,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeInternationalIdcardResponse>> + Send
    {
        self.call(req)
    }

    /// # 混贴发票识别
    ///
    /// 支持各类票据的发票代码、价税合计、合计金额、购买方识别号、开票日期等关键字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云混贴发票识别，是阿里云官方自研OCR文字识别产品，适用于获取多种发票集合在一个页面的场景，需要获取多种发票上的关键信息。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN018t7r7W1mCx440fhmU_!!6000000004919-2-tps-1052-594.png" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |全字段识别|智能识别混贴发票上所包含的全部字段。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=multi_invoice#intro)免费体验本功能识别效果。|
    /// |2|购买[混贴发票识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20211103182712_0880%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeMixedInvoices?lang=PHP&sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP、PDF、OFD。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> URL长度不能超过2048。 </li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |当前支持的发票类型|增值税发票、火车票、机票行程单、出租车票、定额发票、增值税发票卷票、机动车销售发票、网约车行程单、二手车销售统一发票、通用机打发票、客运车船票、过路过桥费发票、社会保障卡、税收完税证明、支付详情页、电商详情页、酒店流水、非税收入发票。|
    /// |相关能力|<ul> <li> [云市场混贴票据识别。](https://market.aliyun.com/products/57124001/cmapi00034969.html?spm=a2c4g.11186623.0.0.6dcb4dcdy2b5CR#sku=yuncode2896900002) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_mixed_invoices(
        &self,
        req: RecognizeMixedInvoices,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeMixedInvoicesResponse>> + Send
    {
        self.call(req)
    }

    /// # 增值税发票识别
    ///
    /// 支持增值税专用发票、增值税普通发票、增值税电子发票识别，支持包括发票代码、发票号码、开票日期、发票金额、发票税额、检验码、购买方税号、销售方税号、发票详情等关键字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云增值税发票识别，是阿里云官方自研OCR文字识别产品，适用于识别增值税发票上所包含的价税合计、发票代码、发票号码等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1D2NXpIKfxu4jSZPfXXb3dXXa-2060-1200.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=invoice#intro)免费体验本功能识别效果。|
    /// |2|购买[增值税发票识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20211103182712_0783%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeInvoice?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// ------
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP、PDF、OFD。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场增值税发票识别。](https://market.aliyun.com/products/57124001/cmapi027758.html?spm=a2c4g.11186623.0.0.1ff64dcdDsX9s8#sku=yuncode2175800000) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_invoice(
        &self,
        req: RecognizeInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeInvoiceResponse>> + Send {
        self.call(req)
    }

    /// # 机动车销售统一发票识别
    ///
    /// 支持包括发票代码、开票号码、开票日期、发票金额、增值税税额、合格证号、购买方名称、购买方身份证号/代码等关键字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云机动车销售发票识别，是阿里云官方自研OCR文字识别产品，适用于识别购车发票上的发票金额、购买方名称、车辆类型、厂牌型号、销售方名称等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1k5AyamslXu8jSZFuXXXg7FXa-2060-1000.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图片格式|支持PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=car_invoice#intro)免费体验本功能识别效果。|
    /// |2|购买[机动车销售发票识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20211103182712_0430%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeCarInvoice?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// ------
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场机动车销售发票识别。](https://market.aliyun.com/products/57124001/cmapi029811.html?spm=a2c4g.11186623.0.0.6dcb4dcdaoX2WN#sku=yuncode2381100001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_car_invoice(
        &self,
        req: RecognizeCarInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeCarInvoiceResponse>> + Send {
        self.call(req)
    }

    /// # 定额发票识别
    ///
    /// 支持包括发票号码、发票代码、发票金额等关键字段结构化识别输出。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_quota_invoice(
        &self,
        req: RecognizeQuotaInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeQuotaInvoiceResponse>> + Send
    {
        self.call(req)
    }

    /// # 航空行程单识别
    ///
    /// 支持包括旅客姓名、身份证号码、电子客票号码、填开日期、填开单位等字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云航空行程单识别，是阿里云官方自研OCR文字识别产品，适用于识别航空行程单所包含的乘机人姓名、身份证号、电子客票号码、验证码、填开日期、销售单位代号、承运人、填开单位、票价、税费、燃油附加费等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 电子发票（航空运输电子客票行程单）暂不支持。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01B5q2Z321hNcDMA9zN_!!6000000007016-2-tps-825-318.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=air_itinerary#intro)免费体验本功能识别效果。|
    /// |2|购买 [票据凭证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20211103182712_0981%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeAirItinerary?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP、OFD、PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li>  </ul>|
    /// |相关能力|<ul> <li> [云市场航空行程单识别。](https://market.aliyun.com/products/57124001/cmapi00035385.html?#sku=yuncode2938500001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_air_itinerary(
        &self,
        req: RecognizeAirItinerary,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeAirItineraryResponse>> + Send
    {
        self.call(req)
    }

    /// # 火车票识别
    ///
    /// 支持包括票号、出发站、到达站、开车时间、票价、座位类型、旅客信息、座位号、车次等字段结构化识别输出。
    /// 2024.12.31更新后，支持电子火车票，增加返回以下新字段：电子客票号、购买方名称、购买方统一信用代码、标题、开票日期、备注。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云火车票识别，是阿里云官方自研OCR文字识别产品，适用于识别火车票上车次、座位号、旅客信息、座位类型、票价等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1n9tZccVl614jSZKPXXaGjpXa-1600-800.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图片格式|支持PNG、JPG、JPEG、BMP、GIF、TIFF、WebP、OFD、PDF。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=train_ticket#intro)免费体验本功能识别效果。|
    /// |2|购买[火车票识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20211103182712_0135%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeTrainInvoice?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// ------
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP、OFD、PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场火车票识别。](https://market.aliyun.com/products/57124001/cmapi020096.html?spm=a2c4g.11186623.0.0.6dcb4dcdaoX2WN&innerSource=search#sku=yuncode1409600000) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_train_invoice(
        &self,
        req: RecognizeTrainInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeTrainInvoiceResponse>> + Send
    {
        self.call(req)
    }

    /// # 出租车发票识别
    ///
    /// 支持包括发票代码、发票号码、日期、发票金额等关键字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云出租车发票识别，是阿里云官方自研OCR文字识别产品，适用于识别出租车发票所包含的发票代码、发票号码、金额、里程等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1.OicXebviK0jSZFNXXaApXXa-364-982.jpg" width="30%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达97%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=taxi_ticket#intro)免费体验本功能识别效果。|
    /// |2|购买[票据凭证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20211103182712_0996%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeTaxiInvoice?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li>  </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_taxi_invoice(
        &self,
        req: RecognizeTaxiInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeTaxiInvoiceResponse>> + Send {
        self.call(req)
    }

    /// # 增值税发票卷票识别
    ///
    /// 支持对卷票上包括发票代码、发票号码、开票日期、发票金额、校验码、大写金额、销售方税号、购买方税号等关键字段结构化识别输出。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_roll_ticket(
        &self,
        req: RecognizeRollTicket,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeRollTicketResponse>> + Send {
        self.call(req)
    }

    /// # 银行承兑汇票识别
    ///
    /// 支持包括出票日期、票据号码、出票人信息、收票人信息、承兑人信息、票据金额等关键字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云银行承兑汇票识别，是阿里云官方自研OCR文字识别产品，适用于识别银行承兑汇票上的出票日期、到期日期、票据状态、票据号码、出票人信息、售票人信息、承兑人信息等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例（仅支持正面识别，暂不支持背面识别）
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN017mjVfp1P2CY21py2u_!!6000000001782-2-tps-2602-1888.png" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图片格式|支持PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=bank_acceptance#intro)免费体验本功能识别效果。|
    /// |2|购买[银行承兑汇票识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20220506145928_0399%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeBankAcceptance?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// ------
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场银行承兑汇票识别。](https://market.aliyun.com/products/57000002/cmapi00040502.html?spm=a2c4g.11186623.0.0.6dcb4dcdaoX2WN&innerSource=search_%E9%93%B6%E6%89%BF#sku=yuncode3450200001) </li> </ul>|
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_bank_acceptance(
        &self,
        req: RecognizeBankAcceptance,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeBankAcceptanceResponse>> + Send
    {
        self.call(req)
    }

    /// # 客运车船票识别
    ///
    /// 支持包括标题、发票号码、出发车站、到达车站、日期、金额等关键字段结构化识别输出。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_bus_ship_ticket(
        &self,
        req: RecognizeBusShipTicket,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeBusShipTicketResponse>> + Send
    {
        self.call(req)
    }

    /// # 非税收入发票识别
    ///
    /// 支持包括票据代码、交款人、票据号码、合计金额、收款单位等关键字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云非税收入发票识别，是阿里云官方自研OCR文字识别产品，适用于识别非税收入发票所包含的票据号码、标题、开票日期、合计金额、收款人等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN01jraEpU29O9qPIWKaT_!!6000000008057-0-tps-2977-1800.jpg" width="40%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达97%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=nontax_invoice#intro)免费体验本功能识别效果。|
    /// |2|购买[车辆物流识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20220303112214_0050%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeNonTaxInvoice?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。</li> </ul> |
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_non_tax_invoice(
        &self,
        req: RecognizeNonTaxInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeNonTaxInvoiceResponse>> + Send
    {
        self.call(req)
    }

    /// # 通用机打发票识别
    ///
    /// 支持包括发票代码、发票号码、销售方名称、销售方识别号、购买方名称、购买方识别号、合计金额等关键字段结构化识别输出。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_common_printed_invoice(
        &self,
        req: RecognizeCommonPrintedInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeCommonPrintedInvoiceResponse>> + Send
    {
        self.call(req)
    }

    /// # 酒店流水识别
    ///
    /// 支持包括房号、入住日期、离店日期、消费总计、付款总计、消费详单等关键字段结构化识别输出。
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_hotel_consume(
        &self,
        req: RecognizeHotelConsume,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeHotelConsumeResponse>> + Send
    {
        self.call(req)
    }

    /// # 支付详情页识别
    ///
    /// 支持包括收款方名称、合计金额、付款方式、商品说明、支付时间等关键字段结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云支付详情页识别，是阿里云官方自研OCR文字识别产品，适用于识别支付详情页所包含的收款方名称、合计金额、付款方式、商品说明、支付时间等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN01pP14mQ1F2WjPhgXev_!!6000000000429-2-tps-821-313.png" width="50%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=nontax_invoice#intro)免费体验本功能识别效果。|
    /// |2|购买[票据凭证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20220303112214_0069%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizePaymentRecord?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。</li> </ul> |
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_payment_record(
        &self,
        req: RecognizePaymentRecord,
    ) -> impl std::future::Future<Output = crate::Result<RecognizePaymentRecordResponse>> + Send
    {
        self.call(req)
    }

    /// # 电商订单页识别
    ///
    /// 支持包括订单编号、收货信息、交易金额、店铺名称、商品详单等关键字段结构化识别输出。
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_purchase_record(
        &self,
        req: RecognizePurchaseRecord,
    ) -> impl std::future::Future<Output = crate::Result<RecognizePurchaseRecordResponse>> + Send
    {
        self.call(req)
    }

    /// # 网约车行程单识别
    ///
    /// 支持网约车行程单全部字段的识别，包括：服务商、申请日期、行程开始时间、行程结束时间、行程人手机号、总金额等字段。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_ride_hailing_itinerary(
        &self,
        req: RecognizeRideHailingItinerary,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeRideHailingItineraryResponse>> + Send
    {
        self.call(req)
    }

    /// # 购物小票识别
    ///
    /// 支持包括开票方名称、开票日期、联系电话、地址、合计（实际）金额等关键字段结构化识别输出。
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_shopping_receipt(
        &self,
        req: RecognizeShoppingReceipt,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeShoppingReceiptResponse>> + Send
    {
        self.call(req)
    }

    /// # 社会保障卡识别
    ///
    /// 支持全字段识别，包括标题、姓名、社会保障号码、社会保障卡号、银行账号、发卡日期等。
    ///
    /// 此接口不再更新，不支持新用户接入。请使用新版接口：[社保卡识别](https://help.aliyun.com/document_detail/442264.html)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_social_security_card(
        &self,
        req: RecognizeSocialSecurityCard,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeSocialSecurityCardResponse>> + Send
    {
        self.call(req)
    }

    /// # 过路过桥费发票识别
    ///
    /// 支持包括发票代码、发票号码、金额、日期、车型、出口、入口等关键字段结构化识别输出。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_toll_invoice(
        &self,
        req: RecognizeTollInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeTollInvoiceResponse>> + Send {
        self.call(req)
    }

    /// # 税收完税证明识别
    ///
    /// 支持包括税务机关、纳税人识别号、纳税人名称、合计金额、填票人、完税详单等关键字段的结构化识别输出。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云税收完税证明识别，是阿里云官方自研OCR文字识别产品，适用于识别非税收入证明所包含的税务机关、纳税人识别号、纳税人名称、合计金额、填票人、完税详单等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN01hmLCcX1JV9xJF1joS_!!6000000001033-2-tps-757-472.png" width="50%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=bill&subtype=tax_clearance_certificate#intro)免费体验本功能识别效果。|
    /// |2|购买[票据凭证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_invoice_dp_cn_20211222173940_0304%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeTaxClearanceCertificate?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。</li> </ul> |
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_tax_clearance_certificate(
        &self,
        req: RecognizeTaxClearanceCertificate,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeTaxClearanceCertificateResponse>> + Send
    {
        self.call(req)
    }

    /// # 二手车统一销售发票识别
    ///
    /// 支持包括发票代码、发票号码、开票日期、发票金额、购买方名称、购买方身份证号等关键字段结构化识别输出。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_used_car_invoice(
        &self,
        req: RecognizeUsedCarInvoice,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeUsedCarInvoiceResponse>> + Send
    {
        self.call(req)
    }

    /// # 营业执照识别
    ///
    /// 可快速精准的识别企业营业执照中的统一社会信用代码、公司名称、地址、主体类型、法定代表人、注册资金、组成形式、成立日期、营业期限和经营范围等关键有效字段。支持营业执照、民办非企业登记证书、社会团体法人登记证书、事业单位法人证书。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云营业执照识别，是阿里云官方自研OCR文字识别产品，适用于识别营业执照上的公司名称、地址、主体类型、法定代表人、注册资金、组成形式、成立日期等关键信息的场景。
    ///   * 泛营业执照包含民办非企业登记证书、社会团体法人登记证书、事业单位法人证书。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01bAhaqS1WxdaE0QfbB_!!6000000002855-0-tps-875-391.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |全字段识别|智能识别营业执照上所包含的全部字段。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|企事业名称、法人代表等文字信息准确率超过95%，营业执照注册号等数字信息准确率超过98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [企业资质识别](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=assets&subtype=blicense#intro)免费体验本功能识别效果。|
    /// |2|购买[营业执照识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_enterprisecard_dp_cn_20211103184836_0975%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeBusinessLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>请保证整张营业执照内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场营业执照识别。](https://market.aliyun.com/products/57124001/cmapi013592.html?spm=5176.730005.result.41.7fc03524S3wFYv&innerSource=search_%E8%90%A5%E4%B8%9A%E6%89%A7%E7%85%A7#sku=yuncode759200000) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_business_license(
        &self,
        req: RecognizeBusinessLicense,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeBusinessLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 银行开户许可证识别
    ///
    /// 可快速精准的识别银行开户许可证中的账号、法定代表人、开户银行、核准号、企业名称、编号等关键信息。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云银行开户许可证识别，是阿里云官方自研OCR文字识别产品，适用于识别银行开户许可证所包含的账号、核准号、企业名称、法人姓名以及开户行等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01h572VA1PARjgZ1TyV_!!6000000001800-2-tps-819-316.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票据凭证识别](https://common-buy.aliyun.com/?commodityCode=ocr_invoice_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=assets&subtype=bank_account_permit#intro)免费体验本功能识别效果。|
    /// |2|购买[银行开户许可证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_enterprisecard_dp_cn_20211103184836_0059%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeBankAccountLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul><li>接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。</li></ul>|
    /// |相关能力|<ul> <li> [云市场银行开户许可证识别。](https://market.aliyun.com/products/57124001/cmapi00042885.html?#sku=yuncode3688500001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_bank_account_license(
        &self,
        req: RecognizeBankAccountLicense,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeBankAccountLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 商标注册证识别
    ///
    /// 可快速精准的识别商标注册证中所包含的商标名称、注册人、注册人地址以及有效期限、核定服务项目等关键有效字段信息。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_trade_mark_certification(
        &self,
        req: RecognizeTradeMarkCertification,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeTradeMarkCertificationResponse>> + Send
    {
        self.call(req)
    }

    /// # 食品生产许可证识别
    ///
    /// 可快速精准的识别食品生产许可证所包含经营者名称、社会信用代码、法定代表人姓名、地址、经营场所、经营项目、有效期、许可证编号等关键字段信息。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云食品生产许可证识别，是阿里云官方自研OCR文字识别产品。适用于识别食品生产许可证社会信用代码、发证机关、生产地址、签发日期等信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1YaMhXKT2gK0jSZFvXXXnFXXa-1414-1000.png" width="50%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [企业资质识别](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=assets&subtype=food_plicense#intro)免费体验本功能识别效果。|
    /// |2|购买 [企业资质识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_enterprisecard_dp_cn_20211103184836_0461%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeFoodProduceLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_food_produce_license(
        &self,
        req: RecognizeFoodProduceLicense,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeFoodProduceLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 食品经营许可证识别
    ///
    /// 可快速精准的识别食品经营许可证所包含生产者名称、社会信用代码、法定代表人姓名、地址、生产场所、食品类别、有效期、许可证编号等关键字段信息。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云食品经营许可证识别，是阿里云官方自研OCR文字识别产品，适用于识别食品经营许可证上的经营者名称、法定代表人名称、社会信用代码等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///    * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1Rwa_N1H2gK0jSZJnXXaT1FXa-2060-800.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图片格式|支持PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [企业资质识别](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=assets&subtype=food_blicense#intro)免费体验本功能识别效果。|
    /// |2|购买[食品经营许可证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_enterprisecard_dp_cn_20211103184836_0564%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeFoodManageLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |相关能力|<ul> <li> [云市场食品经营许可证识别。](https://market.aliyun.com/products/57124001/cmapi033384.html?spm=a2c4g.11186623.0.0.43f6525aYt7UN6#sku=yuncode2738400001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_food_manage_license(
        &self,
        req: RecognizeFoodManageLicense,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeFoodManageLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 医疗器械经营许可证识别
    ///
    /// 可快速精准的识别医疗器械经营许可证所包含许可证编号、企业名称、注册地址、法定代表人、企业负责人、质量管理人、仓库地址、经营范围、许可期限、发证日期等关键字段信息。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_medical_device_manage_license(
        &self,
        req: RecognizeMedicalDeviceManageLicense,
    ) -> impl std::future::Future<
        Output = crate::Result<RecognizeMedicalDeviceManageLicenseResponse>,
    > + Send {
        self.call(req)
    }

    /// # 医疗器械生产许可证识别
    ///
    /// 可快速精准的识别医疗器械生产许可证所包含许可证编号、法定代表人、企业名称、注册地址、生产地址、生产范围、企业负责人、有效期限等关键字段信息。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_medical_device_produce_license(
        &self,
        req: RecognizeMedicalDeviceProduceLicense,
    ) -> impl std::future::Future<
        Output = crate::Result<RecognizeMedicalDeviceProduceLicenseResponse>,
    > + Send {
        self.call(req)
    }

    /// # 第二类医疗器械经营备案凭证识别
    ///
    /// 可快速精准的识别第二类医疗器械经营备案凭证所包含备案编号、企业名称、住所、经营场所、库房地址、经营方式、法定代表人、企业负责人、经营范围、许可期限、备案日期等关键字段信息。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云第二类医疗器械经营备案凭证识别，是阿里云官方自研OCR文字识别产品。适用于识别第二类医疗器械经营备案凭证备案编号、企业名称、经营方式、法定代表人、经营范围等信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN01UQj0kH1u8qOmEehui_!!6000000005993-0-tps-2066-802.jpg" width="45%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [企业资质识别](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=assets&subtype=c2_medical_device_op_record#intro)免费体验本功能识别效果。|
    /// |2|购买 [企业资质识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_enterprisecard_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_enterprisecard_dp_cn_20211103184836_0131%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeCtwoMedicalDeviceManageLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_ctwo_medical_device_manage_license(
        &self,
        req: RecognizeCtwoMedicalDeviceManageLicense,
    ) -> impl std::future::Future<
        Output = crate::Result<RecognizeCtwoMedicalDeviceManageLicenseResponse>,
    > + Send {
        self.call(req)
    }

    /// # 化妆品生产许可证识别
    ///
    /// 支持关键字段识别，包括证照名称、企业名称、社会信用代码、住址、法定代表人、许可证编号等。
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_cosmetic_produce_license(
        &self,
        req: RecognizeCosmeticProduceLicense,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeCosmeticProduceLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 国际企业执照识别
    ///
    /// 支持韩国、印度营业执照类型，提供包括证件类型、公司名称、注册号、法人姓名、签发日期等关键字段的识别能力。
    ///
    /// # Error Codes
    /// - `illegalCountryName`: the country name is not supported.///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_international_business_license(
        &self,
        req: RecognizeInternationalBusinessLicense,
    ) -> impl std::future::Future<
        Output = crate::Result<RecognizeInternationalBusinessLicenseResponse>,
    > + Send {
        self.call(req)
    }

    /// # 行驶证识别
    ///
    /// 支持对行驶证正页、副页关键字段的自动定位和识别，同时也支持对正副页在同一张图片的场景进行自动分割与结构化识别。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云行驶证识别，是阿里云官方自研OCR文字识别产品，精准定位和识别行驶证正、副页所包含的关键信息，支持正副页在同一张图片的场景进行自动分割与结构化识别。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN01ZihUIy1bCzJiSNPrk_!!6000000003430-0-tps-1323-828.jpg" width="70%"></p>
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN017IZ97Q1TdzkT25B2F_!!6000000002406-0-tps-989-517.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |行驶证混贴|支持对正副页在同一张图片的场景进行自动分割与结构化识别。|
    /// |高精度识别|总体准确率达93%以上。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [车辆物流识别](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=logistics&subtype=vehicle_license#intro)免费体验本功能识别效果。|
    /// |2|购买[行驶证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_logistics_dp_cn_20211103160032_0739%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeVehicleLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |国家与语言| <ul> <li>本接口只支持中国行驶证。</li></ul> |
    /// |其他提示|<ul> <li>请保证整张行驶证内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [行驶证识别。](https://market.aliyun.com/products/57124001/cmapi011791.html?spm=5176.730005.result.13.291d3524fc1E2j&innerSource=search_%E8%A1%8C%E9%A9%B6%E8%AF%81#sku=yuncode579100000) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_vehicle_license(
        &self,
        req: RecognizeVehicleLicense,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeVehicleLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 驾驶证识别
    ///
    /// 支持对驾驶证上的姓名、证号、国籍、住址、初次领证日期、准驾类型、有效期等字段进行结构化提取。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云驾驶证识别，是阿里云官方自研OCR文字识别产品，适用于获取驾驶证上的姓名、证号、国籍、住址、准驾类型、初次领证日期、有效期等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN016MD6rM1Clv8MfB6Uz_!!6000000000122-0-tps-787-431.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |全字段识别|智能识别营业执照上所包含的全部字段。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体准确率和召回率达95%以上。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [车辆物流识别](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=logistics&subtype=driving_license#intro)免费体验本功能识别效果。|
    /// |2|购买[驾驶证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_logistics_dp_cn_20211103160032_0001%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeDrivingLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |国家与语言| <ul> <li>本接口只支持中国驾驶证。</li></ul> |
    /// |其他提示|<ul> <li>请保证整张驾驶证内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场驾驶证识别。](https://market.aliyun.com/products/57002002/cmapi010402.html?spm=5176.730005.result.29.34d635246xDdY0&innerSource=search_%E9%A9%BE%E9%A9%B6%E8%AF%81) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_driving_license(
        &self,
        req: RecognizeDrivingLicense,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeDrivingLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 电子面单识别
    ///
    /// 支持识别面单上所有关键字段。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云电子面单识别，是阿里云官方自研OCR文字识别产品，适用于自动提取面单上的手机号进行拨打收件人号码或发短信，减少快递员拨号时间；可快速定位面单上的所需信息，提升快递转运效率。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://help-static-aliyun-doc.aliyuncs.com/assets/img/zh-CN/7133931661/p480011.png" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |全字段识别|智能识别快递运单上所包含的全部字段。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|识别准确率可达93%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [车辆物流识别](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=logistics&subtype=waybill#intro)免费体验本功能识别效果。|
    /// |2|购买[电子面单识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_logistics_dp_cn_20211103160032_0823%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeWaybill?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。 </li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li>  </ul>|
    /// |相关能力|<ul> <li> [云市场电子面单识别。](https://market.aliyun.com/products/57124001/cmapi00043511.html?spm=a2c4g.11186623.0.0.4efc4288F9Ffm7#sku=yuncode3751100001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_waybill(
        &self,
        req: RecognizeWaybill,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeWaybillResponse>> + Send {
        self.call(req)
    }

    /// # 车牌识别
    ///
    /// 可有效识别车辆车牌信息，支持机动车车牌、摩托车车牌以及临时车牌。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云车牌识别，是阿里云官方自研OCR文字识别产品，可有效识别车辆车牌信息，支持多车牌以及多类车型检测识别。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01ornmBX24I8d09nFQV_!!6000000007367-0-tps-661-264.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多地区车牌识别|浙、苏、赣、黑、鄂、川、甘、陕、吉、辽、闽、皖等。|
    /// |多车型识别|大型汽车、小型汽车、新能源车、挂车、临时车牌、警车、军车、使领馆车、教练车、港澳车。|
    /// |使用场景|广泛应用于车辆安防检控、车辆出入识别等场景。|
    /// |高精度识别|总体准确率达93%以上。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [车辆物流识别](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=logistics&subtype=driving_license#intro)免费体验本功能识别效果。|
    /// |2|购买[车牌识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_logistics_dp_cn_20211103160032_0692%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeCarNumber?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>请保证整张车牌内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场车牌识别。](https://market.aliyun.com/products/57124001/cmapi020094.html?spm=5176.730005.result.17.517535242WwEyb&innerSource=search_%E8%BD%A6%E7%89%8C%E8%AF%86%E5%88%AB#sku=yuncode1409400000) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_car_number(
        &self,
        req: RecognizeCarNumber,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeCarNumberResponse>> + Send {
        self.call(req)
    }

    /// # 车辆vin码识别
    ///
    /// 支持识别车辆VIN码。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云VIN码识别，是阿里云官方自研OCR文字识别产品，适用于识别车辆上的VIN码，用于进行车辆质检检查、车辆登记的等场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1.NXUdLzO3e4jSZFxXXaP_FXa-1600-800.jpg" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图片格式|PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [车辆物流识别](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=logistics&subtype=car_vin#intro)免费体验本功能识别效果。|
    /// |2|购买[车辆vin码识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_logistics_dp_cn_20211103160032_0057%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeCarVinCode?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>请保证整张车牌内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场车辆vin码识别。](https://market.aliyun.com/products/57124001/cmapi023049.html?spm=a2c4g.11186623.0.0.3ecb4288iZinrC#sku=yuncode1704900000) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_car_vin_code(
        &self,
        req: RecognizeCarVinCode,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeCarVinCodeResponse>> + Send {
        self.call(req)
    }

    /// # 机动车注册登记证识别
    ///
    /// 可快速精准的识别机动车注册证所包含证件类别、条形编码、登记机关、登记日期、机动车登记编号等关键字段信息。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云机动车注册登记证识别，是阿里云官方自研OCR文字识别产品，适用于识别机动车注册证所包含的证件类型、编号、机动车所有人、登记机关、登记日期等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i3/O1CN01Bi3iwu1EWT0KLLzgX_!!6000000000359-2-tps-635-368.png" width="70%"></p>
    ///
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [车辆物流识别](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=logistics&subtype=vehicle_register#intro)免费体验本功能识别效果。|
    /// |2|购买[车辆物流识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_logistics_dp_cn_20211222171406_0783%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeVehicleRegistration?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场机动车注册登记证识别。](https://market.aliyun.com/products/57124001/cmapi00038697.html?#sku=yuncode3269700001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_vehicle_registration(
        &self,
        req: RecognizeVehicleRegistration,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeVehicleRegistrationResponse>> + Send
    {
        self.call(req)
    }

    /// # 车辆合格证识别
    ///
    /// 支持车辆型号、车辆识别代号、底盘型号、发动机型号等字段进行结构化提取。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云车辆合格证识别，是阿里云官方自研OCR文字识别产品，适用于识别车辆合格证所包含的车辆型号、车辆识别代号、地盘型号、发动机型号等关键信息的场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01myFZQ91pMyaGJpRZn_!!6000000005347-2-tps-562-316.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达97%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [车辆物流识别](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=logistics&subtype=vehicle_certificate#intro)免费体验本功能识别效果。|
    /// |2|购买[车辆合格证识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_logistics_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_logistics_dp_cn_20211222171406_0433%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeVehicleCertification?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li>  </ul>|
    /// |相关能力|<ul> <li> [云市场车辆合格证识别。](https://market.aliyun.com/products/57124001/cmapi00049687.html?#sku=yuncode4368700002) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_vehicle_certification(
        &self,
        req: RecognizeVehicleCertification,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeVehicleCertificationResponse>> + Send
    {
        self.call(req)
    }

    /// # 印刷体数学公式识别
    ///
    /// 支持印刷体的数学公式识别。
    ///
    /// #### 本接口适用场景
    ///   * 阿里云公式识别，是阿里云官方自研OCR文字识别产品，适用于题目录入、智能批改、作业批改等应用场景。
    ///   * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    ///   * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01tW1cGY1U1LxDXWmtJ_!!6000000002457-2-tps-641-318.png" width="60%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [教育场景识别](https://common-buy.aliyun.com/?commodityCode=ocr_education_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=edu&subtype=math_rec#intro)免费体验本功能识别效果。|
    /// |2|购买[教育场景识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_education_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_education_dp_cn_20211103164555_0495%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.html)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEduFormula?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。</li> </ul> |
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_edu_formula(
        &self,
        req: RecognizeEduFormula,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEduFormulaResponse>> + Send {
        self.call(req)
    }

    /// # 口算判题
    ///
    /// 可以识别小学数学口算题目并给出题目判断结果。可支持整数的加减乘除四则运算、整数的混合运算、大小比较、最大数最小数等。
    ///
    /// #### 本接口适用场景
    /// * 阿里云口算判题识别，是阿里云官方自研OCR文字识别产品，适用于整数的加减乘除四则运算、整数的混合运算、大小比较、最大数最小数等的场景。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01JwIWUI1UyR34OnMHv_!!6000000002586-2-tps-636-316.png" width="50%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达97%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [教育场景识别](https://common-buy.aliyun.com/?commodityCode=ocr_education_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=edu&subtype=kousuan#intro)免费体验本功能识别效果。|
    /// |2|购买[教育场景识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_education_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_education_dp_cn_20211103164555_0373%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEduOralCalculation?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场口算判题。](https://market.aliyun.com/products/57124001/cmapi00043293.html?#sku=yuncode3729300001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_edu_oral_calculation(
        &self,
        req: RecognizeEduOralCalculation,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEduOralCalculationResponse>> + Send
    {
        self.call(req)
    }

    /// # 整页试卷识别
    ///
    /// 支持K12全学科扫描场景的整页内容文字识别。接口支持印刷体文本及公式的OCR识别和坐标返回，此外，接口还可对题目中的配图位置进行检测并返回坐标位置。
    ///
    /// #### 本接口适用场景
    /// * 阿里云整页试卷识别，是阿里云官方自研OCR文字识别产品，适用于对练习册、教辅、教材等内容进行整页识别与题目检索场景。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN016bI8WV1TWfQ4ocurU_!!6000000002390-2-tps-739-450.png" width="50%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达97%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [教育场景识别](https://common-buy.aliyun.com/?commodityCode=ocr_education_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=edu&subtype=paper_ocr#intro)免费体验本功能识别效果。|
    /// |2|购买[教育场景识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_education_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_education_dp_cn_20211103164555_0789%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEduPaperOcr?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_edu_paper_ocr(
        &self,
        req: RecognizeEduPaperOcr,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEduPaperOcrResponse>> + Send {
        self.call(req)
    }

    /// # 试卷切题识别
    ///
    /// 支持各学科的教辅试卷的结构化电子录入，将试卷中的题目进行自动化切分和结构化打标，并进行对应题目、题干、选项、答案等内容的结构化输出。
    ///
    /// #### 本接口适用场景
    /// * 阿里云试卷切题识别，是阿里云官方自研OCR文字识别产品，适用于识别整页练习册、试卷或教辅中的题目的场景，适用于教育材料内容的数字化生产与题库录入。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i1/O1CN01DOZA301QjXXwGP8uJ_!!6000000002012-2-tps-1030-942.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |服务|自动切题，并识别其中所包含的文字内容和坐标位置。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |适用范围广|支持K12全学科、多版式扫描版印刷体的整页切题场景。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [教育场景识别](https://common-buy.aliyun.com/?commodityCode=ocr_education_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=edu&subtype=paper_cut#intro)免费体验本功能识别效果。|
    /// |2|购买[试卷切题识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_education_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_education_dp_cn_20211103164555_0194%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEduPaperCut?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> URL长度不能超过2048。 </li>  <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul> <li> [云市场扫描版试卷切题识别。](https://market.aliyun.com/products/57124001/cmapi00042623.html?#sku=yuncode3662300001) </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_edu_paper_cut(
        &self,
        req: RecognizeEduPaperCut,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEduPaperCutResponse>> + Send {
        self.call(req)
    }

    /// # 题目识别
    ///
    /// 可对题目进行有效识别。通过对题目的元素进行打标，提升题目的识别效果。
    ///
    /// #### 本接口适用场景
    /// * 阿里云题目识别，是阿里云官方自研OCR文字识别产品，适用于扫描、拍照场景的单题题目识别，适用于智能批改等场景的题目内容识别。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1KESJj639YK4jSZPcXXXrUFXa-1030-400.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |多文本格式|支持印刷体文本以及公式的OCR识别。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |返回坐标|可实现对题目中的配图位置进行检测并返回坐标位置。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [教育场景识别](https://common-buy.aliyun.com/?commodityCode=ocr_education_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=edu&subtype=question_ocr#intro)免费体验本功能识别效果。|
    /// |2|购买[题目识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_education_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_education_dp_cn_20211103164555_0111%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEduQuestionOcr?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_edu_question_ocr(
        &self,
        req: RecognizeEduQuestionOcr,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEduQuestionOcrResponse>> + Send
    {
        self.call(req)
    }

    /// # 精细版结构化切题
    ///
    /// 支持多学科教辅试卷的结构化识别，将整页练习册、试卷或教辅中的题目进行自动切题，并识别出其中的文字内容和坐标位置。
    ///
    /// #### 本接口适用场景
    /// * 阿里云精细版结构化切题，是阿里云官方自研OCR文字识别产品，适用于整页练习册、试卷或教辅种的题目场景。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i3/O1CN01XxrLu71rjXK95i1lW_!!6000000005667-2-tps-1147-626.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |智能识别|自动切题，并识别其中的全部字段和坐标位置。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [教育场景识别](https://common-buy.aliyun.com/?commodityCode=ocr_education_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=edu&subtype=paper_structured#intro)免费体验本功能识别效果。|
    /// |2|购买[精细版结构化切题资源包](https://common-buy.aliyun.com/?commodityCode=ocr_education_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_education_dp_cn_20211103164555_0978%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEduPaperStructed?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> URL长度不能超过2048。 </li>  <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_edu_paper_structed(
        &self,
        req: RecognizeEduPaperStructed,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEduPaperStructedResponse>> + Send
    {
        self.call(req)
    }

    /// # 通用多语言识别
    ///
    /// 支持国际主流几大语系的自动语言分类判定并返回对应语言的文字信息。
    ///
    /// #### 本接口适用场景
    /// * 阿里云通用多语言证识别，是阿里云官方自研OCR文字识别产品，适用于国际化所需的各类图文识别与信息翻译场景。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i4/O1CN01tVz6Eh1eY0Lb3pUGZ_!!6000000003882-2-tps-640-368.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [通用文字识别](https://common-buy.aliyun.com?commodityCode=ocr_general_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=i18n&subtype=languages#intro)免费体验本功能识别效果。|
    /// |2|购买[小语种识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_multilanguage_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_multilanguage_dp_cn_20211103180438_0408%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeMultiLanguage?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> <li> 图片尺寸过小，会影响识别精度。图片内单字大小在10-50px内时，识别效果较好。 </li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    /// |相关能力|<ul><li>[云市场通用多语言识别。](https://market.aliyun.com/products/57124001/cmapi00040847.html?#sku=yuncode3484700001)</li></ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_multi_language(
        &self,
        req: RecognizeMultiLanguage,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeMultiLanguageResponse>> + Send
    {
        self.call(req)
    }

    /// # 英语作文识别
    ///
    /// 针对全英文图片文档场景下英文印刷体字符高效检测和识别，具备英文专项识别和英文分词功能，支持旋转、表格、文字坐标等多项基础功能。
    ///
    /// #### 本接口适用场景
    /// * 阿里云英语专项识别，是阿里云官方自研OCR文字识别产品，适用于全英文图片、文档场景下的英文印刷体字符的高效检测和识别。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/tfs/TB1K2a4NVY7gK0jSZKzXXaikpXa-2060-800.jpg" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |功能|具备英文专项识别和英文分词功能。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |多卡面类型|支持各种位数、凸字卡面、平面卡面的识别。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [小语种识别](https://common-buy.aliyun.com/?commodityCode=ocr_multilanguage_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=i18n&subtype=eng#intro)免费体验本功能识别效果。|
    /// |2|购买[英语作文识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_multilanguage_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_multilanguage_dp_cn_20211103180438_0108%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeEnglish?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_english(
        &self,
        req: RecognizeEnglish,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeEnglishResponse>> + Send {
        self.call(req)
    }

    /// # 泰语识别
    ///
    /// 针对泰语图片文档场景下泰文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_thai(
        &self,
        req: RecognizeThai,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeThaiResponse>> + Send {
        self.call(req)
    }

    /// # 日语识别
    ///
    /// 针对全日文图片文档场景下日文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_janpanese(
        &self,
        req: RecognizeJanpanese,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeJanpaneseResponse>> + Send {
        self.call(req)
    }

    /// # 韩语识别
    ///
    /// 针对韩语图片文档场景下韩文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_korean(
        &self,
        req: RecognizeKorean,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeKoreanResponse>> + Send {
        self.call(req)
    }

    /// # 拉丁语识别
    ///
    /// 针对拉丁语系的图片文档场景下印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_latin(
        &self,
        req: RecognizeLatin,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeLatinResponse>> + Send {
        self.call(req)
    }

    /// # 俄语识别
    ///
    /// 针对图片文档场景下俄文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_russian(
        &self,
        req: RecognizeRussian,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeRussianResponse>> + Send {
        self.call(req)
    }

    /// # 核酸检测报告识别
    ///
    /// 支持对全国各地区不同版式的核酸检测记录中姓名、证件号码、采样日期、采样时间、检测机构、检测结果等6个关键字段的结构化结果输出。
    ///
    /// #### 本接口适用场景
    /// * 阿里云核酸检测报告识别，是阿里云官方自研OCR文字识别产品，适用于识别核酸检测报告上的姓名、证件号码、采样时间、检测结果等关键信息的场景。
    /// * 阿里云OCR产品基于阿里巴巴达摩院强大的AI技术及海量数据，历经多年沉淀打磨，具有服务稳定、操作简易、实时性高、能力全面等几大优势。
    /// * 本接口图片示例
    /// <p style="text-align:center"><img src="https://img.alicdn.com/imgextra/i2/O1CN01qWUm4s1kF7eX52tJy_!!6000000004653-2-tps-1921-831.png" width="70%"></p>
    ///
    /// #### 本接口核心能力
    ///   
    /// |分类 |概述|
    /// |---|---------|
    /// |图片格式|支持PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。|
    /// |图像增强|默认支持图像增强，包括图像自动旋转、畸变自动矫正、模糊图片自动增强等能力。|
    /// |多类型覆盖|支持模糊、光照不均、透视畸变、任意背景等低质量图像识别。|
    /// |高精度识别|总体识别准确率可达98%。|
    ///
    /// #### 如何使用本接口
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [医疗场景识别](https://common-buy.aliyun.com/?commodityCode=ocr_medical_public_cn) 服务。开通服务前后，您可以通过[体验馆](https://duguang.aliyun.com/experience?type=medicalCare&subtype=covid_test_report#intro)免费体验本功能识别效果。|
    /// |2|购买[核酸检测报告识别资源包](https://common-buy.aliyun.com/?commodityCode=ocr_medical_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_medical_dp_cn_20220506154332_0030%22,%22flowout_spec%22:%22500%22%7D)。本API会赠送免费额度，可使用免费额度测试。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/RecognizeCovidTestReport?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// #### 重要提示
    /// |类型|概述|
    /// |----|-------------------|
    /// |图片格式|<ul> <li>本接口支持：PNG、JPG、JPEG、BMP、GIF、TIFF、WebP。暂不支持PDF格式。</li></ul>|
    /// |图片尺寸|<ul> <li> 图片长宽需要大于15像素，小于8192像素。</li> <li>长宽比需要小于50。</li> <li>如需达到较好识别效果，建议长宽均大于500px。</li> </ul>|
    /// |图片大小|<ul> <li> 图片二进制文件不能超过10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于1.5M图片进行识别，且通过传图片URL的方式调用接口。</li> </ul>|
    /// |其他提示|<ul> <li>接口响应速度和图片中的文字数量有关，如果图片中文字数量越多，接口响应可能越慢。</li> <li> 接口会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li> </ul>|
    ///
    /// # Extra Info
    /// SDK调用
    /// 通过SDK调用此接口的示例请参考[开发者中心](https://next.api.aliyun.com/api-tools/sdk/ocr-api?version=2021-07-07&language=java-tea)
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn recognize_covid_test_report(
        &self,
        req: RecognizeCovidTestReport,
    ) -> impl std::future::Future<Output = crate::Result<RecognizeCovidTestReportResponse>> + Send
    {
        self.call(req)
    }

    /// # 营业执照核验
    ///
    /// 营业执照三要素核验支持通过输入营业执照的统一信用社会代码（工商注册号）、企业名称、法人姓名做一致性验证。
    ///
    /// #### 如何开通/购买本服务
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票证核验](https://common-buy.aliyun.com/?spm=5176.28059030.0.0.68c21287dXK0hR&commodityCode=ocr_cardverification_public_cn) 服务。开通后您可享50次免费额度。|
    /// |2|购买[营业执照核验资源包](https://common-buy.aliyun.com/?commodityCode=ocr_cardverification_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_cardverification_dp_cn_20220826134917_0698%22,%22flowout_spec%22:%221000%22%7D%E3%80%91)。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.htm?spm=a2c4g.11186623.0.0.22878a21R9tkuV)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/VerifyBusinessLicense?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// # Error Codes
    /// - `ServiceUnavailable`: The request has failed due to a temporary failure of the server///
    /// # Extra Info
    /// * <span style="font-size:larger;"> <b> 返回结果示例 </b></span>
    /// ```ignore
    /// // 三要素核验一致
    /// {
    ///   "data": "{\"code\":\"0\",\"data\":true,\"message\":\"法人姓名、社会信用代码一致\"}",
    ///   "requestId": "E5CDCE98-EC32-16AC-B851-EDFC4C9B7F2D"
    /// }
    ///
    ///
    /// // 公司不存在
    /// {
    ///   "data": "{\"code\":\"20001\",\"data\":false,\"message\":\"此公司在数据库中不存在！\"}",
    ///   "requestId": "E5CDCE98-EC32-16AC-B851-EDFC4C9B7F2D"
    /// }
    ///
    ///
    /// // 法人名字不一致
    /// {
    ///   "data": "{\"code\":\"20002\",\"data\":false,\"message\":\"输入的法人名字和公司法人名字不一致\"}",
    ///   "requestId": "E5CDCE98-EC32-16AC-B851-EDFC4C9B7F2D"
    /// }
    ///
    ///
    /// // 三要素都不一致
    /// {
    ///   "data": "{\"code\":\"20003\",\"data\":false,\"message\":\"传入的注册号与工商注册号和统一社会信用代码都不一致\"}",
    ///   "requestId": "E5CDCE98-EC32-16AC-B851-EDFC4C9B7F2D"
    /// }
    ///
    /// ```
    ///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn verify_business_license(
        &self,
        req: VerifyBusinessLicense,
    ) -> impl std::future::Future<Output = crate::Result<VerifyBusinessLicenseResponse>> + Send
    {
        self.call(req)
    }

    /// # 发票核验
    ///
    /// 发票核验接口支持包括：增值税专用发票、增值税普通发票（折叠票）、增值税普通发票（卷票）、增值税电子普通发票（含收费公路通行费增值税电子普通发票）、机动车销售统一发票、二手车销售统一发票多种类型发票核验。您可以通过输入发票的关键验证字段，返回真实的票面信息，包括发票类型、发票代码、发票号码、作废标志、开票日期、购方税号及其他发票信息等。当天开具发票当日可查验（T+0）。注意：可能有几小时到十几小时的延迟。
    ///
    /// #### 如何开通/购买本服务
    ///
    /// |步骤|概述|
    /// |--|---|
    /// |1|开通 [票证核验](https://common-buy.aliyun.com/?spm=5176.28059030.0.0.68c21287dXK0hR&commodityCode=ocr_cardverification_public_cn) 服务。开通后您可享50次免费额度。|
    /// |2|购买[发票核验资源包](https://common-buy.aliyun.com/?commodityCode=ocr_cardverification_dp_cn&request=%7B%22ord_time%22:%221:Year%22,%22order_num%22:1,%22pack%22:%22ocr_cardverification_dp_cn_20220830140650_0595%22,%22flowout_spec%22:%221000%22%7D)。您也可以不购买资源包，系统会通过“[按量付费](https://help.aliyun.com/document_detail/295347.htm?spm=a2c4g.11186623.0.0.22878a21R9tkuV)”方式按实际调用量自动扣款。|
    /// |3|可以参照[调试页面](https://next.api.aliyun.com/api/ocr-api/2021-07-07/VerifyVATInvoice?sdkStyle=dara)提供的代码示例完成API接入开发。接入完成后，调用API获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对RAM账号进行授权。创建RAM用户的具体操作，请参考：[创建RAM用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为RAM用户授权。](https://help.aliyun.com/document_detail/116146.html)|
    ///
    /// # Error Codes
    /// - `ServiceUnavailable`: The request has failed due to a temporary failure of the server///
    /// # Methods
    /// - GET
    /// - POST
    ///
    pub fn verify_vat_invoice(
        &self,
        req: VerifyVATInvoice,
    ) -> impl std::future::Future<Output = crate::Result<VerifyVATInvoiceResponse>> + Send {
        self.call(req)
    }
}

/// OCR统一识别接口支持识别多种图片类型，包括通用文字、个人卡证、发票等。您只需要通过Type参数指定图片类型，无须更换接口。
///
/// Argument of [Connection::recognize_all_text()], returns [RecognizeAllTextResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeAllText {
    /// - 本字段和 body 字段二选一，不可同时透传或同时为空。
    /// - 图片链接（长度不超过2048字节，不支持 base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// - 本字段和 URL 字段二选一，不可同时透传或同时为空。
    /// - 图片二进制文件，最大 10MB。
    /// - 使用 HTTP 方式调用，把图片二进制文件放到 HTTP body 中上传即可。
    /// - 使用 SDK 的方式调用，把图片放到 SDK 的 body 中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 图片类型。**必选**参数，且为**单选**。
    /// * 支持的图片类型请参考 **请求参数补充说明**。
    /// * 请注意，对于票据卡证类图片，当图片真实类型和入参指定的**Type**不一致时，会导致识别失败。
    r#type: TextType,
    /// - 是否需要图案检测功能。如果开启，会返回**FigureInfo**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：不同图片类型（**Type**）的默认值不同，详见**请求参数补充说明**。
    /// - 支持识别的图案类型如下：
    ///     - blicense_title：营业执照标题
    ///     - national_emblem：国徽
    ///     - face：人脸图案
    ///     - finger_print：指纹
    ///     - signature：签名区域
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要识别图案时开启此参数。
    #[setters(generate = true, strip_option)]
    output_figure: Option<bool>,
    /// - 是否需要二维码检测功能。开启后会返回**QrCodeInfo**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要识别二维码时开启此参数。
    #[setters(generate = true, strip_option)]
    output_qrcode: Option<bool>,
    /// - 是否需要条形码检测功能。开启后会返回**BarCodeInfo**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要识别条形码时开启此参数。
    #[setters(generate = true, strip_option)]
    output_bar_code: Option<bool>,
    /// - 是否需要印章检测功能。开启后会返回**StampInfo**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要识别印章时开启此参数。
    #[setters(generate = true, strip_option)]
    output_stamp: Option<bool>,
    /// - 返回坐标格式（**points**、**rectangle**）。
    /// - points：四点坐标；rectangle：旋转矩形。
    /// - 默认不需要传此参数，不返回文字坐标。
    #[setters(generate = true, strip_option)]
    output_coordinate: Option<String>,
    /// - 是否需要返回原图坐标信息。 系统会自动对图片做处理（比如自动旋转、图片校正等），您可以设置返回的坐标口径，是“原图坐标”或“算法处理后图片坐标”。
    /// - true：需要；false：不需要。
    /// - 默认值：不同图片类型（**Type**）的默认值不同，详见**请求参数补充说明**。
    /// - **请注意**：仅当**OutputCoordinate**不为空时，设置此参数才有意义。
    #[setters(generate = true, strip_option)]
    output_oricoord: Option<bool>,
    /// - 是否需要把识别出的结构化信息转成 Excel 文件链接（默认不需要）。
    /// - true：需要；false：不需要。
    /// - 文件链接有效期为一小时。
    /// - **注意**：开启此参数后，会增加接口的响应时间，请在需要时开启。
    #[setters(generate = true, strip_option)]
    output_kv_excel: Option<bool>,
    /// 当图片类型为混贴票证/增值税发票/定额发票航空行程单/火车票增值税发票卷票/通用机打发票时（即Type=MixedInvoice/Invoice/QuotaInvoice/AirItinerary/TrainTicket/RollTicket/CommonPrintedInvoice），可通过本字段设置可选功能。
    /// - 指定识别的 PDF/OFD 页码；例如：PageNo=6，则识别 PDF/OFD 的第六页。
    /// - 如果不传此参数，或传值大于 PDF/OFD 总页数，则识别 PDF/OFD 的第一页。
    /// - 默认识别第一页。
    #[setters(generate = true, strip_option)]
    page_no: Option<i32>,
    /// * 当图片类型为通用文字识别高精版时（**Type=Advanced**），可通过本字段设置可选功能。
    #[setters(generate = true, strip_option)]
    advanced_config: Option<AdvancedConfig>,
    /// * 当图片类型为身份证时（**Type=IdCard**），可通过本字段设置可选功能。
    #[setters(generate = true, strip_option)]
    id_card_config: Option<TextIdCardConfig>,
    /// * 当图片类型为国际身份证时（Type=**InternationalIdCard**），可通过本字段设置可选功能。
    #[setters(generate = true, strip_option)]
    international_id_card_config: Option<InternationalIdCardConfig>,
    /// * 当图片类型为国际企业执照时（Type=**InternationalBusinessLicense**），可通过本字段设置可选功能。
    #[setters(generate = true, strip_option)]
    international_business_license_config: Option<LicenseConfig>,
    /// * 当图片类型为通用多语言文字时（Type=**MultiLang**），可通过本字段设置可选功能。
    #[setters(generate = true, strip_option)]
    multi_lan_config: Option<LanConfig>,
    /// * 当图片类型为表格时（Type=**Table**），可通过本字段设置可选功能。
    #[setters(generate = true, strip_option)]
    table_config: Option<TableConfig>,
}

impl sealed::Bound for RecognizeAllText {}

impl RecognizeAllText {
    pub fn new(r#type: impl Into<TextType>) -> Self {
        Self {
            url: None,
            body: None,
            r#type: r#type.into(),
            output_figure: None,
            output_qrcode: None,
            output_bar_code: None,
            output_stamp: None,
            output_coordinate: None,
            output_oricoord: None,
            output_kv_excel: None,
            page_no: None,
            advanced_config: None,
            id_card_config: None,
            international_id_card_config: None,
            international_business_license_config: None,
            multi_lan_config: None,
            table_config: None,
        }
    }
}

impl crate::Request for RecognizeAllText {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeAllText";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeAllTextResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(16);

        if let Some(f) = &self.advanced_config {
            if let Ok(json) = serde_json::to_string(f) {
                params.push(("AdvancedConfig".into(), json.into()));
            }
        }

        if let Some(f) = &self.id_card_config {
            if let Ok(json) = serde_json::to_string(f) {
                params.push(("IdCardConfig".into(), json.into()));
            }
        }

        if let Some(f) = &self.international_business_license_config {
            if let Ok(json) = serde_json::to_string(f) {
                params.push(("InternationalBusinessLicenseConfig".into(), json.into()));
            }
        }

        if let Some(f) = &self.international_id_card_config {
            if let Ok(json) = serde_json::to_string(f) {
                params.push(("InternationalIdCardConfig".into(), json.into()));
            }
        }

        if let Some(f) = &self.multi_lan_config {
            if let Ok(json) = serde_json::to_string(f) {
                params.push(("MultiLanConfig".into(), json.into()));
            }
        }

        if let Some(f) = &self.output_bar_code {
            params.push(("OutputBarCode".into(), (f).into()));
        }

        if let Some(f) = &self.output_coordinate {
            params.push(("OutputCoordinate".into(), (f).into()));
        }

        if let Some(f) = &self.output_figure {
            params.push(("OutputFigure".into(), (f).into()));
        }

        if let Some(f) = &self.output_kv_excel {
            params.push(("OutputKVExcel".into(), (f).into()));
        }

        if let Some(f) = &self.output_oricoord {
            params.push(("OutputOricoord".into(), (f).into()));
        }

        if let Some(f) = &self.output_qrcode {
            params.push(("OutputQrcode".into(), (f).into()));
        }

        if let Some(f) = &self.output_stamp {
            params.push(("OutputStamp".into(), (f).into()));
        }

        if let Some(f) = &self.page_no {
            params.push(("PageNo".into(), (f).into()));
        }

        if let Some(f) = &self.table_config {
            if let Ok(json) = serde_json::to_string(f) {
                params.push(("TableConfig".into(), json.into()));
            }
        }
        params.push(("Type".into(), (&self.r#type).into()));

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 通用票证抽取结合读光OCR和通义千问大模型的能力，针对OCR不支持的长尾票据，提供关键KV信息抽取，例如名称、地址、开票日期等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_general_structure()], returns [RecognizeGeneralStructureResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeGeneralStructure {
    /// * 本字段和 body 字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超过2048字节，不支持 base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和 URL 字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大 10MB。
    /// * 使用 HTTP 方式调用，把图片二进制文件放到 HTTP body 中上传即可。
    /// * 使用 SDK 的方式调用，把图片放到 SDK 的 body 中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 需要抽取的所有Key（字符串数组）。
    /// * 默认值为**空**，表示由大模型自动判断需要抽取的Key。
    /// * Key的上限数量为**30**（包含30）。
    /// * 建议调用接口时传此参数，减小接口耗时。**请注意**：接口响应时间和Key的数量呈正相关关系。
    #[setters(generate = true, strip_option)]
    keys: Option<Vec<String>>,
}

impl sealed::Bound for RecognizeGeneralStructure {}

impl RecognizeGeneralStructure {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            keys: None,
        }
    }
}

impl crate::Request for RecognizeGeneralStructure {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeGeneralStructure";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeGeneralStructureResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.keys {
            crate::SimpleSerialize::simple_serialize(f, "Keys", &mut params);
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持多格式版面、复杂文档背景和光照环境的精准识别，可实现印章擦除后识别，支持低置信度过滤、图案检测等高阶功能。
///
/// Argument of [Connection::recognize_advanced()], returns [RecognizeAdvancedResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeAdvanced {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否输出单字识别结果，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// * 是否需要自动旋转功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// * 是否输出表格识别结果，包含单元格信息，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
    /// * 是否按顺序输出文字块，默认为false。
    /// * false表示从左往右，从上到下的顺序；true表示从上到下，从左往右的顺序。
    #[setters(generate = true, strip_option)]
    need_sort_page: Option<bool>,
    /// * 是否需要图案检测功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_figure: Option<bool>,
    /// * 是否需要去除印章功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    no_stamp: Option<bool>,
    /// * 是否需要分段功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    paragraph: Option<bool>,
    /// * 是否需要成行返回功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    row: Option<bool>,
}

impl sealed::Bound for RecognizeAdvanced {}

impl RecognizeAdvanced {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_char_info: None,
            need_rotate: None,
            output_table: None,
            need_sort_page: None,
            output_figure: None,
            no_stamp: None,
            paragraph: None,
            row: None,
        }
    }
}

impl crate::Request for RecognizeAdvanced {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeAdvanced";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeAdvancedResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(9);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.need_sort_page {
            params.push(("NeedSortPage".into(), (f).into()));
        }

        if let Some(f) = &self.no_stamp {
            params.push(("NoStamp".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_figure {
            params.push(("OutputFigure".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.paragraph {
            params.push(("Paragraph".into(), (f).into()));
        }

        if let Some(f) = &self.row {
            params.push(("Row".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持中文手写体、英文手写体、数字手写体等各种复杂场景的手写文字识别。
///
/// Argument of [Connection::recognize_handwriting()], returns [RecognizeHandwritingResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeHandwriting {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否输出单字识别结果，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// * 是否需要自动旋转功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// * 是否输出表格识别结果，包含单元格信息，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
    /// * 是否按顺序输出文字块，默认为false。
    /// * false表示从左往右，从上到下的顺序；true表示从上到下，从左往右的顺序。
    #[setters(generate = true, strip_option)]
    need_sort_page: Option<bool>,
    /// * 是否需要分段功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    paragraph: Option<bool>,
}

impl sealed::Bound for RecognizeHandwriting {}

impl RecognizeHandwriting {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_char_info: None,
            need_rotate: None,
            output_table: None,
            need_sort_page: None,
            paragraph: None,
        }
    }
}

impl crate::Request for RecognizeHandwriting {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeHandwriting";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeHandwritingResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(6);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.need_sort_page {
            params.push(("NeedSortPage".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.paragraph {
            params.push(("Paragraph".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 针对电商商品宣传图片、社区贴吧图片、网络UGC图片等网络场景下图片字符快速精准识别。
///
/// Argument of [Connection::recognize_basic()], returns [RecognizeBasicResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeBasic {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否需要自动旋转功能，默认需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
}

impl sealed::Bound for RecognizeBasic {}

impl RecognizeBasic {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            need_rotate: None,
        }
    }
}

impl crate::Request for RecognizeBasic {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeBasic";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeBasicResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 适用于非结构化文字识别，支持返回文字内容和位置坐标信息。
///
/// Argument of [Connection::recognize_general()], returns [RecognizeGeneralResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeGeneral {
    /// * 本字段和body字段二选一，不可同时透传或同时为空
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeGeneral {}

impl RecognizeGeneral {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeGeneral {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeGeneral";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeGeneralResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持对有线表格、条纹表格、无线表格进行有效识别。
///
/// Argument of [Connection::recognize_table_ocr()], returns [RecognizeTableOcrResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeTableOcr {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否需要自动旋转功能，默认需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// * 是否无线条或者只有横线没有竖线,默认有线条。
    /// * true：无线条；false：有线条。
    #[setters(generate = true, strip_option)]
    line_less: Option<bool>,
    /// * 是否跳过检测，默认为false。
    /// * true：跳过检查；false：不跳过检查。
    #[setters(generate = true, strip_option)]
    skip_detection: Option<bool>,
    /// * 是否是手写表格，默认不是。
    /// * true：是手写表格；false：不是手写表格。
    /// * 注意：该字段是字符串类型。
    #[setters(generate = true, strip_option)]
    is_hand_writing: Option<HandWriting>,
}

impl sealed::Bound for RecognizeTableOcr {}

impl RecognizeTableOcr {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            need_rotate: None,
            line_less: None,
            skip_detection: None,
            is_hand_writing: None,
        }
    }
}

impl crate::Request for RecognizeTableOcr {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeTableOcr";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeTableOcrResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(5);

        if let Some(f) = &self.is_hand_writing {
            params.push(("IsHandWriting".into(), (f).into()));
        }

        if let Some(f) = &self.line_less {
            params.push(("LineLess".into(), (f).into()));
        }

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.skip_detection {
            params.push(("SkipDetection".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 包括全国主要省市健康码，支持健康码图片的姓名、日期、时间、颜色、备注信息等主要字段的识别结果输出。
///
/// Argument of [Connection::recognize_health_code()], returns [RecognizeHealthCodeResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeHealthCode {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeHealthCode {}

impl RecognizeHealthCode {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeHealthCode {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeHealthCode";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeHealthCodeResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 对文档信息进行结构化识别，并提供元素平铺和层级树两种视角的版面信息输出。能够将文档中的文字元素（单字、文字块、行等）和相应的版面格式（标题、段落、表格）抽离并按顺序输出。
///
/// Argument of [Connection::recognize_document_structure()], returns [RecognizeDocumentStructureResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeDocumentStructure {
    /// 图片链接（长度不超2048字节，不支持 base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。
    /// 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。
    /// 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 是否需要自动旋转功能，返回角度信息。默认不需要。true：需要 false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// 是否输出单字识别结果，默认不需要。true：需要 false：不需要。
    /// 当UseNewStyleOutput=true时，此参数不生效。
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// 是否输出表格识别结果，包含单元格信息。默认不需要。true：需要 false：不需要。
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
    /// 是否按顺序输出文字块，默认不需要。true：需要 false：不需要。false表示从左往右，从上到下的顺序；true表示从上到下，从左往右的顺序。
    /// 当UseNewStyleOutput=true时，此参数不生效。
    #[setters(generate = true, strip_option)]
    need_sort_page: Option<bool>,
    /// 是否需要分页功能，默认不需要。 true：需要 false：不需要。
    /// 当UseNewStyleOutput=true时，此参数不生效。
    #[setters(generate = true, strip_option)]
    page: Option<bool>,
    /// 是否需要去除印章功能，默认不需要。true：需要 false：不需要
    #[setters(generate = true, strip_option)]
    no_stamp: Option<bool>,
    /// 是否需要分段功能，默认不需要。true：需要 false：不需要。
    /// 当UseNewStyleOutput=true时，此参数不生效。
    #[setters(generate = true, strip_option)]
    paragraph: Option<bool>,
    /// 是否需要成行返回功能，默认不需要。true：需要 false：不需要。
    /// 当UseNewStyleOutput=true时，此参数不生效。
    #[setters(generate = true, strip_option)]
    row: Option<bool>,
    /// 是否返回新版格式输出，默认为false
    #[setters(generate = true, strip_option)]
    use_new_style_output: Option<bool>,
}

impl sealed::Bound for RecognizeDocumentStructure {}

impl RecognizeDocumentStructure {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            need_rotate: None,
            output_char_info: None,
            output_table: None,
            need_sort_page: None,
            page: None,
            no_stamp: None,
            paragraph: None,
            row: None,
            use_new_style_output: None,
        }
    }
}

impl crate::Request for RecognizeDocumentStructure {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeDocumentStructure";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeDocumentStructureResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(10);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.need_sort_page {
            params.push(("NeedSortPage".into(), (f).into()));
        }

        if let Some(f) = &self.no_stamp {
            params.push(("NoStamp".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.page {
            params.push(("Page".into(), (f).into()));
        }

        if let Some(f) = &self.paragraph {
            params.push(("Paragraph".into(), (f).into()));
        }

        if let Some(f) = &self.row {
            params.push(("Row".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        if let Some(f) = &self.use_new_style_output {
            params.push(("UseNewStyleOutput".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持二代身份证正反面，包括姓名、性别、民族、地址、出生日期、身份证号、签发机关、有效期限等字段的结构化识别。支持身份证质量检测，是否翻拍，是否是复印件，完整度评分，整体质量分数、篡改指数及人脸位置检测。
///
/// Argument of [Connection::recognize_idcard()], returns [RecognizeIdcardResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeIdcard {
    /// * 本字段和body字段二选一，不可同时传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否需要图案检测功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_figure: Option<bool>,
    /// * 是否需要身份证质量检测功能，默认不需要。
    /// * 身份证质量检测功能包含：是否翻拍，是否是复印件，完整度评分，整体质量分数、篡改指数。
    /// * 注意：如果需要设置此参数，请使用最新版本SDK。如果不需要设置此参数，您无需更新SDK。
    #[setters(generate = true, strip_option)]
    output_quality_info: Option<bool>,
    #[setters(generate = true, strip_option)]
    llm_rec: Option<bool>,
}

impl sealed::Bound for RecognizeIdcard {}

impl RecognizeIdcard {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_figure: None,
            output_quality_info: None,
            llm_rec: None,
        }
    }
}

impl crate::Request for RecognizeIdcard {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeIdcard";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeIdcardResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);

        if let Some(f) = &self.llm_rec {
            params.push(("Llm_rec".into(), (f).into()));
        }

        if let Some(f) = &self.output_figure {
            params.push(("OutputFigure".into(), (f).into()));
        }

        if let Some(f) = &self.output_quality_info {
            params.push(("OutputQualityInfo".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可对美国、法国、英国、日本、韩国等世界多个主要国家和地区护照提供识别服务，支持字段包括国籍、护照号码、出生日期、姓名等。
///
/// Argument of [Connection::recognize_passport()], returns [RecognizePassportResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizePassport {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizePassport {}

impl RecognizePassport {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizePassport {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizePassport";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizePassportResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可结构化识别户口常住人口登记卡页面及户主页的内容，有效识别户口本上的相关户籍证明信息。
///
/// Argument of [Connection::recognize_household()], returns [RecognizeHouseholdResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeHousehold {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否是户口本常住人口页，默认为否。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    is_resident_page: Option<bool>,
}

impl sealed::Bound for RecognizeHousehold {}

impl RecognizeHousehold {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            is_resident_page: None,
        }
    }
}

impl crate::Request for RecognizeHousehold {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeHousehold";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeHouseholdResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.is_resident_page {
            params.push(("IsResidentPage".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可准确识别不动产证中的各项关键信息，包括户主信息、房屋地址、面积大小、土地权利类型等，适用于全国各地的不同房产证识别。
///
/// Argument of [Connection::recognize_estate_certification()], returns [RecognizeEstateCertificationResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEstateCertification {
    /// * 本字段和BODY字段二选一，不可同时透传或同时为空。
    ///   * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    ///   * 图片二进制文件，最大10MB。
    ///   * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    ///   * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeEstateCertification {}

impl RecognizeEstateCertification {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeEstateCertification {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEstateCertification";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEstateCertificationResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可精准识别各类银行卡中的银行卡卡号和有效期，且支持横卡、竖卡及银行卡任意角度偏斜情况的识别与提取，支持中国内地大多数银行，以及各种位数、凸字卡面、平面卡面等的识别。
///
/// Argument of [Connection::recognize_bank_card()], returns [RecognizeBankCardResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeBankCard {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeBankCard {}

impl RecognizeBankCard {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeBankCard {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeBankCard";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeBankCardResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可准确识别出生证明中的各项关键信息，包括出生日期、出生体重、出生地点等。
///
/// Argument of [Connection::recognize_birth_certification()], returns [RecognizeBirthCertificationResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeBirthCertification {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeBirthCertification {}

impl RecognizeBirthCertification {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeBirthCertification {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeBirthCertification";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeBirthCertificationResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持中国人民共和国护照的结构化内容检测识别功能，支持中国内地、中国香港、中国澳门和中国台湾地区的护照识别，识别内容包括出生地、出生日期、国籍、性别、护照号码、有效期至、签发国、签发地等字段。
///
/// Argument of [Connection::recognize_chinese_passport()], returns [RecognizeChinesePassportResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeChinesePassport {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 是否需要图案检测功能，默认需要
    #[setters(generate = true, strip_option)]
    output_figure: Option<bool>,
}

impl sealed::Bound for RecognizeChinesePassport {}

impl RecognizeChinesePassport {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_figure: None,
        }
    }
}

impl crate::Request for RecognizeChinesePassport {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeChinesePassport";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeChinesePassportResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.output_figure {
            params.push(("OutputFigure".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可准确识别通行证中的各项关键信息，包括姓名、出生日期、证件号码等。包括港澳居民来往大陆通行证以及台湾居民来往大陆通行证。
///
/// Argument of [Connection::recognize_exit_entry_permit_to_mainland()], returns [RecognizeExitEntryPermitToMainlandResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeExitEntryPermitToMainland {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否需要图案检测功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_figure: Option<bool>,
}

impl sealed::Bound for RecognizeExitEntryPermitToMainland {}

impl RecognizeExitEntryPermitToMainland {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_figure: None,
        }
    }
}

impl crate::Request for RecognizeExitEntryPermitToMainland {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeExitEntryPermitToMainland";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeExitEntryPermitToMainlandResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.output_figure {
            params.push(("OutputFigure".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持通行证中的各项关键信息，姓名、出生日期、证件号码等字段的准确识别。
///
/// Argument of [Connection::recognize_exit_entry_permit_to_hk()], returns [RecognizeExitEntryPermitToHKResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeExitEntryPermitToHK {
    /// 图片链接（长度不超 2048字节，不支持 base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 图案坐标信息输出，针对结构化，如身份证人脸头像
    #[setters(generate = true, strip_option)]
    output_figure: Option<bool>,
}

impl sealed::Bound for RecognizeExitEntryPermitToHK {}

impl RecognizeExitEntryPermitToHK {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_figure: None,
        }
    }
}

impl crate::Request for RecognizeExitEntryPermitToHK {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeExitEntryPermitToHK";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeExitEntryPermitToHKResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.output_figure {
            params.push(("OutputFigure".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持香港永久性居民身份证和香港居民身份证两种类型的证件识别，已支持全字段识别，包括中文姓名（如有）、英文姓名、中文姓名电码（如有）、出生日期、性别、符号标记、身份证号码等。
///
/// Argument of [Connection::recognize_hk_idcard()], returns [RecognizeHKIdcardResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeHKIdcard {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeHKIdcard {}

impl RecognizeHKIdcard {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeHKIdcard {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeHKIdcard";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeHKIdcardResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持全字段识别，包括标题、姓名、社会保障号码、社会保障卡号、银行账号、发卡日期等。
///
/// Argument of [Connection::recognize_social_security_card_version_ii()], returns [RecognizeSocialSecurityCardVersionIIResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeSocialSecurityCardVersionII {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeSocialSecurityCardVersionII {}

impl RecognizeSocialSecurityCardVersionII {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeSocialSecurityCardVersionII {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeSocialSecurityCardVersionII";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeSocialSecurityCardVersionIIResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可对国外身份证件进行结构化识别，目前支持越南、韩国、印度、孟加拉居民身份证，可识别字段包括姓名、出生日期、证件号码等。
///
/// Argument of [Connection::recognize_international_idcard()], returns [RecognizeInternationalIdcardResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeInternationalIdcard {
    /// * 本字段和BODY字段二选一，不可同时透传或同时为空。
    ///   * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    ///   * 图片二进制文件，最大10MB。
    ///   * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    ///   * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 国家名称。
    ///   * 如：India，Vietnam，Korea，Bangladesh。
    country: IdcardCountry,
}

impl sealed::Bound for RecognizeInternationalIdcard {}

impl RecognizeInternationalIdcard {
    pub fn new(country: impl Into<IdcardCountry>) -> Self {
        Self {
            url: None,
            body: None,
            country: country.into(),
        }
    }
}

impl crate::Request for RecognizeInternationalIdcard {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeInternationalIdcard";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeInternationalIdcardResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);
        params.push(("Country".into(), (&self.country).into()));

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持各类票据的发票代码、价税合计、合计金额、购买方识别号、开票日期等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_mixed_invoices()], returns [RecognizeMixedInvoicesResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeMixedInvoices {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 待识别的PDF/OFD页码。
    /// * 如果字段为空，或大于PDF/OFD总页数，则识别第一页。
    /// * 使用SDK设置此字段，请更新SDK版本。
    #[setters(generate = true, strip_option)]
    page_no: Option<i32>,
    /// * 是否合并PDF的**前几页**，并返回合并页的识别结果（最大支持返回**前4页**识别结果）。例如上传的PDF有**3页**，且设置此参数为**true**，返回前**3页**所有识别结果。
    /// * 默认为**false**。
    /// * 如果上传的PDF总页数大于**4页**，且设置此参数为**true**，则只识别**前4页**（此参数不支持选择任意页码号）。
    /// * 如果设置了 **PageNo**，同时 **MergePdfPages** 设置为**true**，则 **MergePdfPages** 不生效，会识别 **PageNo** 指定的PDF页面。
    #[setters(generate = true, strip_option)]
    merge_pdf_pages: Option<bool>,
}

impl sealed::Bound for RecognizeMixedInvoices {}

impl RecognizeMixedInvoices {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            page_no: None,
            merge_pdf_pages: None,
        }
    }
}

impl crate::Request for RecognizeMixedInvoices {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeMixedInvoices";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeMixedInvoicesResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(3);

        if let Some(f) = &self.merge_pdf_pages {
            params.push(("MergePdfPages".into(), (f).into()));
        }

        if let Some(f) = &self.page_no {
            params.push(("PageNo".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持增值税专用发票、增值税普通发票、增值税电子发票识别，支持包括发票代码、发票号码、开票日期、发票金额、发票税额、检验码、购买方税号、销售方税号、发票详情等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_invoice()], returns [RecognizeInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeInvoice {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 指定识别的PDF/OFD页码；例如：pageNo=6，识别PDF/OFD的第六页。
    /// * 如果该参数为空，或传值大于PDF/OFD总页数，则识别PDF/OFD的第一页。
    /// * 如果使用SDK设置此参数，请更新SDK版本，该参数在SDK版本1.1.16开始支持。
    #[setters(generate = true, strip_option)]
    page_no: Option<i32>,
}

impl sealed::Bound for RecognizeInvoice {}

impl RecognizeInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            page_no: None,
        }
    }
}

impl crate::Request for RecognizeInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.page_no {
            params.push(("PageNo".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括发票代码、开票号码、开票日期、发票金额、增值税税额、合格证号、购买方名称、购买方身份证号/代码等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_car_invoice()], returns [RecognizeCarInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeCarInvoice {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeCarInvoice {}

impl RecognizeCarInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeCarInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeCarInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeCarInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括发票号码、发票代码、发票金额等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_quota_invoice()], returns [RecognizeQuotaInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeQuotaInvoice {
    /// 图片链接（长度不超2048字节，不支持 base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeQuotaInvoice {}

impl RecognizeQuotaInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeQuotaInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeQuotaInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeQuotaInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括旅客姓名、身份证号码、电子客票号码、填开日期、填开单位等字段结构化识别输出。
///
/// Argument of [Connection::recognize_air_itinerary()], returns [RecognizeAirItineraryResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeAirItinerary {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeAirItinerary {}

impl RecognizeAirItinerary {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeAirItinerary {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeAirItinerary";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeAirItineraryResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括票号、出发站、到达站、开车时间、票价、座位类型、旅客信息、座位号、车次等字段结构化识别输出。
/// 2024.12.31更新后，支持电子火车票，增加返回以下新字段：电子客票号、购买方名称、购买方统一信用代码、标题、开票日期、备注。
///
/// Argument of [Connection::recognize_train_invoice()], returns [RecognizeTrainInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeTrainInvoice {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeTrainInvoice {}

impl RecognizeTrainInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeTrainInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeTrainInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeTrainInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括发票代码、发票号码、日期、发票金额等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_taxi_invoice()], returns [RecognizeTaxiInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeTaxiInvoice {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeTaxiInvoice {}

impl RecognizeTaxiInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeTaxiInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeTaxiInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeTaxiInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持对卷票上包括发票代码、发票号码、开票日期、发票金额、校验码、大写金额、销售方税号、购买方税号等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_roll_ticket()], returns [RecognizeRollTicketResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeRollTicket {
    /// 图片链接（长度不超2048字节，不支持 base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeRollTicket {}

impl RecognizeRollTicket {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeRollTicket {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeRollTicket";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeRollTicketResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括出票日期、票据号码、出票人信息、收票人信息、承兑人信息、票据金额等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_bank_acceptance()], returns [RecognizeBankAcceptanceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeBankAcceptance {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    ///   * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeBankAcceptance {}

impl RecognizeBankAcceptance {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeBankAcceptance {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeBankAcceptance";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeBankAcceptanceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括标题、发票号码、出发车站、到达车站、日期、金额等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_bus_ship_ticket()], returns [RecognizeBusShipTicketResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeBusShipTicket {
    /// 图片链接（长度不超2048字节，不支持 base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeBusShipTicket {}

impl RecognizeBusShipTicket {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeBusShipTicket {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeBusShipTicket";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeBusShipTicketResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括票据代码、交款人、票据号码、合计金额、收款单位等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_non_tax_invoice()], returns [RecognizeNonTaxInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeNonTaxInvoice {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeNonTaxInvoice {}

impl RecognizeNonTaxInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeNonTaxInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeNonTaxInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeNonTaxInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括发票代码、发票号码、销售方名称、销售方识别号、购买方名称、购买方识别号、合计金额等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_common_printed_invoice()], returns [RecognizeCommonPrintedInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeCommonPrintedInvoice {
    /// 图片链接（长度不超2048字节，不支持 base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeCommonPrintedInvoice {}

impl RecognizeCommonPrintedInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeCommonPrintedInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeCommonPrintedInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeCommonPrintedInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括房号、入住日期、离店日期、消费总计、付款总计、消费详单等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_hotel_consume()], returns [RecognizeHotelConsumeResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeHotelConsume {
    /// 图片链接（长度不超2048字节，不支持 base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeHotelConsume {}

impl RecognizeHotelConsume {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeHotelConsume {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeHotelConsume";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeHotelConsumeResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括收款方名称、合计金额、付款方式、商品说明、支付时间等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_payment_record()], returns [RecognizePaymentRecordResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizePaymentRecord {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizePaymentRecord {}

impl RecognizePaymentRecord {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizePaymentRecord {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizePaymentRecord";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizePaymentRecordResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括订单编号、收货信息、交易金额、店铺名称、商品详单等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_purchase_record()], returns [RecognizePurchaseRecordResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizePurchaseRecord {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否需要识别多条订单，默认不需要。
    /// * true：需要；false：不需要。
    /// * 如果需要使用此参数，请更新SDK到1.1.14或更高版本。
    /// * 注意：如果此参数设置为true，返回结果字段会变化。
    #[setters(generate = true, strip_option)]
    output_multi_orders: Option<bool>,
}

impl sealed::Bound for RecognizePurchaseRecord {}

impl RecognizePurchaseRecord {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_multi_orders: None,
        }
    }
}

impl crate::Request for RecognizePurchaseRecord {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizePurchaseRecord";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizePurchaseRecordResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.output_multi_orders {
            params.push(("OutputMultiOrders".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持网约车行程单全部字段的识别，包括：服务商、申请日期、行程开始时间、行程结束时间、行程人手机号、总金额等字段。
///
/// Argument of [Connection::recognize_ride_hailing_itinerary()], returns [RecognizeRideHailingItineraryResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeRideHailingItinerary {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeRideHailingItinerary {}

impl RecognizeRideHailingItinerary {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeRideHailingItinerary {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeRideHailingItinerary";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeRideHailingItineraryResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括开票方名称、开票日期、联系电话、地址、合计（实际）金额等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_shopping_receipt()], returns [RecognizeShoppingReceiptResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeShoppingReceipt {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeShoppingReceipt {}

impl RecognizeShoppingReceipt {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeShoppingReceipt {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeShoppingReceipt";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeShoppingReceiptResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持全字段识别，包括标题、姓名、社会保障号码、社会保障卡号、银行账号、发卡日期等。
///
/// Argument of [Connection::recognize_social_security_card()], returns [RecognizeSocialSecurityCardResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeSocialSecurityCard {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeSocialSecurityCard {}

impl RecognizeSocialSecurityCard {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeSocialSecurityCard {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeSocialSecurityCard";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeSocialSecurityCardResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括发票代码、发票号码、金额、日期、车型、出口、入口等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_toll_invoice()], returns [RecognizeTollInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeTollInvoice {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeTollInvoice {}

impl RecognizeTollInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeTollInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeTollInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeTollInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括税务机关、纳税人识别号、纳税人名称、合计金额、填票人、完税详单等关键字段的结构化识别输出。
///
/// Argument of [Connection::recognize_tax_clearance_certificate()], returns [RecognizeTaxClearanceCertificateResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeTaxClearanceCertificate {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeTaxClearanceCertificate {}

impl RecognizeTaxClearanceCertificate {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeTaxClearanceCertificate {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeTaxClearanceCertificate";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeTaxClearanceCertificateResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持包括发票代码、发票号码、开票日期、发票金额、购买方名称、购买方身份证号等关键字段结构化识别输出。
///
/// Argument of [Connection::recognize_used_car_invoice()], returns [RecognizeUsedCarInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeUsedCarInvoice {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeUsedCarInvoice {}

impl RecognizeUsedCarInvoice {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeUsedCarInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeUsedCarInvoice";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeUsedCarInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别企业营业执照中的统一社会信用代码、公司名称、地址、主体类型、法定代表人、注册资金、组成形式、成立日期、营业期限和经营范围等关键有效字段。支持营业执照、民办非企业登记证书、社会团体法人登记证书、事业单位法人证书。
///
/// Argument of [Connection::recognize_business_license()], returns [RecognizeBusinessLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeBusinessLicense {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeBusinessLicense {}

impl RecognizeBusinessLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeBusinessLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeBusinessLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeBusinessLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别银行开户许可证中的账号、法定代表人、开户银行、核准号、企业名称、编号等关键信息。
///
/// Argument of [Connection::recognize_bank_account_license()], returns [RecognizeBankAccountLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeBankAccountLicense {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeBankAccountLicense {}

impl RecognizeBankAccountLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeBankAccountLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeBankAccountLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeBankAccountLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别商标注册证中所包含的商标名称、注册人、注册人地址以及有效期限、核定服务项目等关键有效字段信息。
///
/// Argument of [Connection::recognize_trade_mark_certification()], returns [RecognizeTradeMarkCertificationResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeTradeMarkCertification {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeTradeMarkCertification {}

impl RecognizeTradeMarkCertification {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeTradeMarkCertification {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeTradeMarkCertification";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeTradeMarkCertificationResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别食品生产许可证所包含经营者名称、社会信用代码、法定代表人姓名、地址、经营场所、经营项目、有效期、许可证编号等关键字段信息。
///
/// Argument of [Connection::recognize_food_produce_license()], returns [RecognizeFoodProduceLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeFoodProduceLicense {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeFoodProduceLicense {}

impl RecognizeFoodProduceLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeFoodProduceLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeFoodProduceLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeFoodProduceLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别食品经营许可证所包含生产者名称、社会信用代码、法定代表人姓名、地址、生产场所、食品类别、有效期、许可证编号等关键字段信息。
///
/// Argument of [Connection::recognize_food_manage_license()], returns [RecognizeFoodManageLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeFoodManageLicense {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeFoodManageLicense {}

impl RecognizeFoodManageLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeFoodManageLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeFoodManageLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeFoodManageLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别医疗器械经营许可证所包含许可证编号、企业名称、注册地址、法定代表人、企业负责人、质量管理人、仓库地址、经营范围、许可期限、发证日期等关键字段信息。
///
/// Argument of [Connection::recognize_medical_device_manage_license()], returns [RecognizeMedicalDeviceManageLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeMedicalDeviceManageLicense {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeMedicalDeviceManageLicense {}

impl RecognizeMedicalDeviceManageLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeMedicalDeviceManageLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeMedicalDeviceManageLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeMedicalDeviceManageLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别医疗器械生产许可证所包含许可证编号、法定代表人、企业名称、注册地址、生产地址、生产范围、企业负责人、有效期限等关键字段信息。
///
/// Argument of [Connection::recognize_medical_device_produce_license()], returns [RecognizeMedicalDeviceProduceLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeMedicalDeviceProduceLicense {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeMedicalDeviceProduceLicense {}

impl RecognizeMedicalDeviceProduceLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeMedicalDeviceProduceLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeMedicalDeviceProduceLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeMedicalDeviceProduceLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别第二类医疗器械经营备案凭证所包含备案编号、企业名称、住所、经营场所、库房地址、经营方式、法定代表人、企业负责人、经营范围、许可期限、备案日期等关键字段信息。
///
/// Argument of [Connection::recognize_ctwo_medical_device_manage_license()], returns [RecognizeCtwoMedicalDeviceManageLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeCtwoMedicalDeviceManageLicense {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeCtwoMedicalDeviceManageLicense {}

impl RecognizeCtwoMedicalDeviceManageLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeCtwoMedicalDeviceManageLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeCtwoMedicalDeviceManageLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeCtwoMedicalDeviceManageLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持关键字段识别，包括证照名称、企业名称、社会信用代码、住址、法定代表人、许可证编号等。
///
/// Argument of [Connection::recognize_cosmetic_produce_license()], returns [RecognizeCosmeticProduceLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeCosmeticProduceLicense {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制字节流，最大10MB
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeCosmeticProduceLicense {}

impl RecognizeCosmeticProduceLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeCosmeticProduceLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeCosmeticProduceLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeCosmeticProduceLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持韩国、印度营业执照类型，提供包括证件类型、公司名称、注册号、法人姓名、签发日期等关键字段的识别能力。
///
/// Argument of [Connection::recognize_international_business_license()], returns [RecognizeInternationalBusinessLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeInternationalBusinessLicense {
    /// 图片/PDF 链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片/PDF二进制字节流，最大10M
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 国家名称
    country: LicenseCountry,
}

impl sealed::Bound for RecognizeInternationalBusinessLicense {}

impl RecognizeInternationalBusinessLicense {
    pub fn new(country: impl Into<LicenseCountry>) -> Self {
        Self {
            url: None,
            body: None,
            country: country.into(),
        }
    }
}

impl crate::Request for RecognizeInternationalBusinessLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeInternationalBusinessLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeInternationalBusinessLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);
        params.push(("Country".into(), (&self.country).into()));

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持对行驶证正页、副页关键字段的自动定位和识别，同时也支持对正副页在同一张图片的场景进行自动分割与结构化识别。
///
/// Argument of [Connection::recognize_vehicle_license()], returns [RecognizeVehicleLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeVehicleLicense {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeVehicleLicense {}

impl RecognizeVehicleLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeVehicleLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeVehicleLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeVehicleLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持对驾驶证上的姓名、证号、国籍、住址、初次领证日期、准驾类型、有效期等字段进行结构化提取。
///
/// Argument of [Connection::recognize_driving_license()], returns [RecognizeDrivingLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeDrivingLicense {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeDrivingLicense {}

impl RecognizeDrivingLicense {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeDrivingLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeDrivingLicense";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeDrivingLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持识别面单上所有关键字段。
///
/// Argument of [Connection::recognize_waybill()], returns [RecognizeWaybillResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeWaybill {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeWaybill {}

impl RecognizeWaybill {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeWaybill {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeWaybill";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeWaybillResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可有效识别车辆车牌信息，支持机动车车牌、摩托车车牌以及临时车牌。
///
/// Argument of [Connection::recognize_car_number()], returns [RecognizeCarNumberResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeCarNumber {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeCarNumber {}

impl RecognizeCarNumber {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeCarNumber {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeCarNumber";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeCarNumberResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持识别车辆VIN码。
///
/// Argument of [Connection::recognize_car_vin_code()], returns [RecognizeCarVinCodeResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeCarVinCode {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeCarVinCode {}

impl RecognizeCarVinCode {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeCarVinCode {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeCarVinCode";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeCarVinCodeResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可快速精准的识别机动车注册证所包含证件类别、条形编码、登记机关、登记日期、机动车登记编号等关键字段信息。
///
/// Argument of [Connection::recognize_vehicle_registration()], returns [RecognizeVehicleRegistrationResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeVehicleRegistration {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeVehicleRegistration {}

impl RecognizeVehicleRegistration {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeVehicleRegistration {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeVehicleRegistration";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeVehicleRegistrationResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持车辆型号、车辆识别代号、底盘型号、发动机型号等字段进行结构化提取。
///
/// Argument of [Connection::recognize_vehicle_certification()], returns [RecognizeVehicleCertificationResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeVehicleCertification {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeVehicleCertification {}

impl RecognizeVehicleCertification {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeVehicleCertification {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeVehicleCertification";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeVehicleCertificationResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持印刷体的数学公式识别。
///
/// Argument of [Connection::recognize_edu_formula()], returns [RecognizeEduFormulaResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEduFormula {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeEduFormula {}

impl RecognizeEduFormula {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeEduFormula {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEduFormula";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEduFormulaResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可以识别小学数学口算题目并给出题目判断结果。可支持整数的加减乘除四则运算、整数的混合运算、大小比较、最大数最小数等。
///
/// Argument of [Connection::recognize_edu_oral_calculation()], returns [RecognizeEduOralCalculationResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEduOralCalculation {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
}

impl sealed::Bound for RecognizeEduOralCalculation {}

impl RecognizeEduOralCalculation {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
        }
    }
}

impl crate::Request for RecognizeEduOralCalculation {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEduOralCalculation";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEduOralCalculationResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(1);

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持K12全学科扫描场景的整页内容文字识别。接口支持印刷体文本及公式的OCR识别和坐标返回，此外，接口还可对题目中的配图位置进行检测并返回坐标位置。
///
/// Argument of [Connection::recognize_edu_paper_ocr()], returns [RecognizeEduPaperOcrResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEduPaperOcr {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 图片类型。
    /// * scan：扫描图， photo：实拍图。
    image_type: String,
    /// * 年级学科。
    /// * default:默认, Math:数学, PrimarySchool_Math:小学数学, JHighSchool_Math: 初中数学, Chinese:语文, PrimarySchool_Chinese:小学语文, JHighSchool_Chinese:初中语文, English:英语, PrimarySchool_English:小学英语, JHighSchool_English:初中英语, Physics:物理, JHighSchool_Physics:初中物理, Chemistry: 化学, JHighSchool_Chemistry:初中化学, Biology:生物, JHighSchool_Biology:初中生物, History:历史, JHighSchool_History:初中历史, Geography:地理, JHighSchool_Geography:初中地理, Politics:政治, JHighSchool_Politics:初中政治。
    #[setters(generate = true, strip_option)]
    subject: Option<String>,
    /// * 是否输出原图坐标信息（如果图片被做过旋转，图片校正等处理），默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_oricoord: Option<bool>,
}

impl sealed::Bound for RecognizeEduPaperOcr {}

impl RecognizeEduPaperOcr {
    pub fn new(image_type: impl Into<String>) -> Self {
        Self {
            url: None,
            body: None,
            image_type: image_type.into(),
            subject: None,
            output_oricoord: None,
        }
    }
}

impl crate::Request for RecognizeEduPaperOcr {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEduPaperOcr";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEduPaperOcrResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);
        params.push(("ImageType".into(), (&self.image_type).into()));

        if let Some(f) = &self.output_oricoord {
            params.push(("OutputOricoord".into(), (f).into()));
        }

        if let Some(f) = &self.subject {
            params.push(("Subject".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持各学科的教辅试卷的结构化电子录入，将试卷中的题目进行自动化切分和结构化打标，并进行对应题目、题干、选项、答案等内容的结构化输出。
///
/// Argument of [Connection::recognize_edu_paper_cut()], returns [RecognizeEduPaperCutResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEduPaperCut {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 切题类型。
    /// * question：题目， answer：答案。
    cut_type: String,
    /// * 图片类型。
    /// * scan：扫描图， photo：实拍图。
    image_type: String,
    /// * 年级学科。
    /// * default:默认, Math:数学, PrimarySchool_Math:小学数学, JHighSchool_Math: 初中数学, Chinese:语文, PrimarySchool_Chinese:小学语文, JHighSchool_Chinese:初中语文, English:英语, PrimarySchool_English:小学英语, JHighSchool_English:初中英语, Physics:物理, JHighSchool_Physics:初中物理, Chemistry: 化学, JHighSchool_Chemistry:初中化学, Biology:生物, JHighSchool_Biology:初中生物, History:历史, JHighSchool_History:初中历史, Geography:地理, JHighSchool_Geography:初中地理, Politics:政治, JHighSchool_Politics:初中政治。
    #[setters(generate = true, strip_option)]
    subject: Option<String>,
    /// * 是否输出原图坐标信息（如果图片被做过旋转，图片校正等处理），默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_oricoord: Option<bool>,
}

impl sealed::Bound for RecognizeEduPaperCut {}

impl RecognizeEduPaperCut {
    pub fn new(cut_type: impl Into<String>, image_type: impl Into<String>) -> Self {
        Self {
            url: None,
            body: None,
            cut_type: cut_type.into(),
            image_type: image_type.into(),
            subject: None,
            output_oricoord: None,
        }
    }
}

impl crate::Request for RecognizeEduPaperCut {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEduPaperCut";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEduPaperCutResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(5);
        params.push(("CutType".into(), (&self.cut_type).into()));
        params.push(("ImageType".into(), (&self.image_type).into()));

        if let Some(f) = &self.output_oricoord {
            params.push(("OutputOricoord".into(), (f).into()));
        }

        if let Some(f) = &self.subject {
            params.push(("Subject".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 可对题目进行有效识别。通过对题目的元素进行打标，提升题目的识别效果。
///
/// Argument of [Connection::recognize_edu_question_ocr()], returns [RecognizeEduQuestionOcrResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEduQuestionOcr {
    /// * 本字段和BODY字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否需要自动旋转功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
}

impl sealed::Bound for RecognizeEduQuestionOcr {}

impl RecognizeEduQuestionOcr {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            need_rotate: None,
        }
    }
}

impl crate::Request for RecognizeEduQuestionOcr {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEduQuestionOcr";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEduQuestionOcrResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持多学科教辅试卷的结构化识别，将整页练习册、试卷或教辅中的题目进行自动切题，并识别出其中的文字内容和坐标位置。
///
/// Argument of [Connection::recognize_edu_paper_structed()], returns [RecognizeEduPaperStructedResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEduPaperStructed {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 年级学科。
    /// * default:默认, Math:数学, PrimarySchool_Math:小学数学, JHighSchool_Math: 初中数学, Chinese:语文, PrimarySchool_Chinese:小学语文, JHighSchool_Chinese:初中语文, English:英语, PrimarySchool_English:小学英语, JHighSchool_English:初中英语, Physics:物理, JHighSchool_Physics:初中物理, Chemistry: 化学, JHighSchool_Chemistry:初中化学, Biology:生物, JHighSchool_Biology:初中生物, History:历史, JHighSchool_History:初中历史, Geography:地理, JHighSchool_Geography:初中地理, Politics:政治, JHighSchool_Politics:初中政治。
    #[setters(generate = true, strip_option)]
    subject: Option<String>,
    /// * 是否需要自动旋转功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// * 是否输出原图坐标信息（如果图片被做过旋转，图片校正等处理），默认不需要。
    /// * 如需输出原图坐标，建议同时将NeedRotate参数设置为true。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_oricoord: Option<bool>,
}

impl sealed::Bound for RecognizeEduPaperStructed {}

impl RecognizeEduPaperStructed {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            subject: None,
            need_rotate: None,
            output_oricoord: None,
        }
    }
}

impl crate::Request for RecognizeEduPaperStructed {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEduPaperStructed";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEduPaperStructedResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.output_oricoord {
            params.push(("OutputOricoord".into(), (f).into()));
        }

        if let Some(f) = &self.subject {
            params.push(("Subject".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持国际主流几大语系的自动语言分类判定并返回对应语言的文字信息。
///
/// Argument of [Connection::recognize_multi_language()], returns [RecognizeMultiLanguageResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeMultiLanguage {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 支持语言列表。
    languages: Vec<String>,
    /// * 是否输出单字识别结果，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// * 是否需要自动旋转功能，默认需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// * 是否输出表格识别结果，包含单元格信息，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
    /// * 是否按顺序输出文字块，默认为false。
    /// * false表示从左往右，从上到下的顺序；true表示从上到下，从左往右的顺序。
    #[setters(generate = true, strip_option)]
    need_sort_page: Option<bool>,
}

impl sealed::Bound for RecognizeMultiLanguage {}

impl RecognizeMultiLanguage {
    pub fn new(languages: impl Into<Vec<String>>) -> Self {
        Self {
            url: None,
            body: None,
            languages: languages.into(),
            output_char_info: None,
            need_rotate: None,
            output_table: None,
            need_sort_page: None,
        }
    }
}

impl crate::Request for RecognizeMultiLanguage {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeMultiLanguage";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeMultiLanguageResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(6);
        crate::SimpleSerialize::simple_serialize(&self.languages, "Languages", &mut params);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.need_sort_page {
            params.push(("NeedSortPage".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 针对全英文图片文档场景下英文印刷体字符高效检测和识别，具备英文专项识别和英文分词功能，支持旋转、表格、文字坐标等多项基础功能。
///
/// Argument of [Connection::recognize_english()], returns [RecognizeEnglishResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeEnglish {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 是否需要自动旋转功能，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// * 是否输出表格识别结果，包含单元格信息，默认不需要。
    /// * true：需要；false：不需要。
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
}

impl sealed::Bound for RecognizeEnglish {}

impl RecognizeEnglish {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            need_rotate: None,
            output_table: None,
        }
    }
}

impl crate::Request for RecognizeEnglish {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeEnglish";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeEnglishResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(3);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 针对泰语图片文档场景下泰文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
///
/// Argument of [Connection::recognize_thai()], returns [RecognizeThaiResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeThai {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 是否输出单字识别结果
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// 是否需要自动旋转功能（结构化检测、混贴场景、教育相关场景会自动做旋转，无需设置），返回角度信息
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// 是否输出表格识别结果，包含单元格信息
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
}

impl sealed::Bound for RecognizeThai {}

impl RecognizeThai {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_char_info: None,
            need_rotate: None,
            output_table: None,
        }
    }
}

impl crate::Request for RecognizeThai {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeThai";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeThaiResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 针对全日文图片文档场景下日文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
///
/// Argument of [Connection::recognize_janpanese()], returns [RecognizeJanpaneseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeJanpanese {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 是否输出单字识别结果
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// 是否需要自动旋转功能（结构化检测、混贴场景、教育相关场景会自动做旋转，无需设置），返回角度信息
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// 是否输出表格识别结果，包含单元格信息
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
}

impl sealed::Bound for RecognizeJanpanese {}

impl RecognizeJanpanese {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_char_info: None,
            need_rotate: None,
            output_table: None,
        }
    }
}

impl crate::Request for RecognizeJanpanese {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeJanpanese";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeJanpaneseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 针对韩语图片文档场景下韩文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
///
/// Argument of [Connection::recognize_korean()], returns [RecognizeKoreanResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeKorean {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 是否输出单字识别结果
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// 是否需要自动旋转功能（结构化检测、混贴场景、教育相关场景会自动做旋转，无需设置），返回角度信息
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// 是否输出表格识别结果，包含单元格信息
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
}

impl sealed::Bound for RecognizeKorean {}

impl RecognizeKorean {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_char_info: None,
            need_rotate: None,
            output_table: None,
        }
    }
}

impl crate::Request for RecognizeKorean {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeKorean";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeKoreanResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 针对拉丁语系的图片文档场景下印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
///
/// Argument of [Connection::recognize_latin()], returns [RecognizeLatinResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeLatin {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 是否输出单字识别结果
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// 是否需要自动旋转功能（结构化检测、混贴场景、教育相关场景会自动做旋转，无需设置），返回角度信息
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// 是否输出表格识别结果，包含单元格信息
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
}

impl sealed::Bound for RecognizeLatin {}

impl RecognizeLatin {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_char_info: None,
            need_rotate: None,
            output_table: None,
        }
    }
}

impl crate::Request for RecognizeLatin {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeLatin";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeLatinResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 针对图片文档场景下俄文印刷体高效检测和识别，支持旋转、表格、文字坐标等多项基础功能。
///
/// Argument of [Connection::recognize_russian()], returns [RecognizeRussianResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeRussian {
    /// 图片链接（长度不超2048字节，不支持base64）
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// 图片二进制文件，最大10MB，与URL二选一。 使用HTTP方式调用，把图片二进制文件放到HTTP body 中上传即可。 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// 是否输出单字识别结果
    #[setters(generate = true, strip_option)]
    output_char_info: Option<bool>,
    /// 是否需要自动旋转功能（结构化检测、混贴场景、教育相关场景会自动做旋转，无需设置），返回角度信息
    #[setters(generate = true, strip_option)]
    need_rotate: Option<bool>,
    /// 是否输出表格识别结果，包含单元格信息
    #[setters(generate = true, strip_option)]
    output_table: Option<bool>,
}

impl sealed::Bound for RecognizeRussian {}

impl RecognizeRussian {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            output_char_info: None,
            need_rotate: None,
            output_table: None,
        }
    }
}

impl crate::Request for RecognizeRussian {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeRussian";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeRussianResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(4);

        if let Some(f) = &self.need_rotate {
            params.push(("NeedRotate".into(), (f).into()));
        }

        if let Some(f) = &self.output_char_info {
            params.push(("OutputCharInfo".into(), (f).into()));
        }

        if let Some(f) = &self.output_table {
            params.push(("OutputTable".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 支持对全国各地区不同版式的核酸检测记录中姓名、证件号码、采样日期、采样时间、检测机构、检测结果等6个关键字段的结构化结果输出。
///
/// Argument of [Connection::recognize_covid_test_report()], returns [RecognizeCovidTestReportResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct RecognizeCovidTestReport {
    /// * 本字段和body字段二选一，不可同时透传或同时为空。
    /// * 图片链接（长度不超2048字节，不支持base64）。
    #[setters(generate = true, strip_option)]
    url: Option<String>,
    /// * 本字段和URL字段二选一，不可同时透传或同时为空。
    /// * 图片二进制文件，最大10MB。
    /// * 使用HTTP方式调用，把图片二进制文件放到HTTP body中上传即可。
    /// * 使用SDK的方式调用，把图片放到SDK的body中即可。
    #[setters(generate = true, strip_option)]
    body: Option<Vec<u8>>,
    /// * 当一张图有多个子图时，是否要返回多个识别结果,默认不需要。
    /// * true：返回所有子图识别结果；false：返回检测日期最新的一个结果。
    #[setters(generate = true, strip_option)]
    multiple_result: Option<bool>,
}

impl sealed::Bound for RecognizeCovidTestReport {}

impl RecognizeCovidTestReport {
    pub fn new() -> Self {
        Self {
            url: None,
            body: None,
            multiple_result: None,
        }
    }
}

impl crate::Request for RecognizeCovidTestReport {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "RecognizeCovidTestReport";

    type Body = crate::OctetStream;

    type ResponseWrap = crate::JsonResponseWrap<RecognizeCovidTestReportResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(2);

        if let Some(f) = &self.multiple_result {
            params.push(("MultipleResult".into(), (f).into()));
        }

        if let Some(f) = &self.url {
            params.push(("Url".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::OctetStream(self.body.unwrap_or_default())
    }
}

/// 营业执照三要素核验支持通过输入营业执照的统一信用社会代码（工商注册号）、企业名称、法人姓名做一致性验证。
///
/// Argument of [Connection::verify_business_license()], returns [VerifyBusinessLicenseResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct VerifyBusinessLicense {
    /// 企业注册号或统一社会信用代码
    credit_code: String,
    /// 企业名称
    company_name: String,
    /// 企业法人姓名
    legal_person: String,
}

impl sealed::Bound for VerifyBusinessLicense {}

impl VerifyBusinessLicense {
    pub fn new(
        credit_code: impl Into<String>,
        company_name: impl Into<String>,
        legal_person: impl Into<String>,
    ) -> Self {
        Self {
            credit_code: credit_code.into(),
            company_name: company_name.into(),
            legal_person: legal_person.into(),
        }
    }
}
impl crate::ToFormData for VerifyBusinessLicense {
    fn to_form_data(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        Default::default()
    }
}

impl crate::Request for VerifyBusinessLicense {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "VerifyBusinessLicense";

    type Body = crate::Form<Self>;

    type ResponseWrap = crate::JsonResponseWrap<VerifyBusinessLicenseResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(3);
        params.push(("CompanyName".into(), (&self.company_name).into()));
        params.push(("CreditCode".into(), (&self.credit_code).into()));
        params.push(("LegalPerson".into(), (&self.legal_person).into()));

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::Form(self)
    }
}

/// 发票核验接口支持包括：增值税专用发票、增值税普通发票（折叠票）、增值税普通发票（卷票）、增值税电子普通发票（含收费公路通行费增值税电子普通发票）、机动车销售统一发票、二手车销售统一发票多种类型发票核验。您可以通过输入发票的关键验证字段，返回真实的票面信息，包括发票类型、发票代码、发票号码、作废标志、开票日期、购方税号及其他发票信息等。当天开具发票当日可查验（T+0）。注意：可能有几小时到十几小时的延迟。
///
/// Argument of [Connection::verify_vat_invoice()], returns [VerifyVATInvoiceResponse].
#[derive(derive_setters::Setters, Debug)]
#[setters(generate = false)]
pub struct VerifyVATInvoice {
    /// 发票代码。数电发票（发票类型代码为31，32，51，61，83，84）时可为空（发票类型代码见**发票类型代码说明**）。
    #[setters(generate = true, strip_option)]
    invoice_code: Option<String>,
    /// 发票号码。
    invoice_no: String,
    /// 开票日期（日期格式为：YYYYMMDD）。
    invoice_date: String,
    /// 发票金额。发票类型代码为 01，03，15，20，31，32 ，51，61，85，83，84时必填：为 01，03，20 ,85时填写发票**不含税金额**；为 15 ,84时填写发票**车价合计**；为 31，32 ，51，61，83时填写**含税金额**；为区块链发票（InvoiceKind=1）时填写 **不含税金额**。
    /// 其它类型可为空（详见**发票类型代码说明**）。
    #[setters(generate = true, strip_option)]
    invoice_sum: Option<String>,
    /// 校验码，取**后6位**。发票类型代码为 04，10，11，14，86 时必填，发票类型代码为 86 时，填写密码区数电票号码后六位，为区块链发票（InvoiceKind=1）时必填，其他发票种类可为空（详见**发票类型代码说明**）。
    #[setters(generate = true, strip_option)]
    verify_code: Option<String>,
    /// 发票类型。用来区分是否为 **区块链发票**。
    /// * InvoiceKind=0 或不填，表示 **非区块链发票**。
    /// * InvoiceKind=1，表示 **区块链发票**。注意，如果核验区块链发票，则 **InvoiceCode**，**InvoiceNumber**，**InvoiceDate**，**InvoiceSum**，**VerifyCode** 这5个入参均为必传参数。
    #[setters(generate = true, strip_option)]
    invoice_kind: Option<i32>,
}

impl sealed::Bound for VerifyVATInvoice {}

impl VerifyVATInvoice {
    pub fn new(invoice_no: impl Into<String>, invoice_date: impl Into<String>) -> Self {
        Self {
            invoice_code: None,
            invoice_no: invoice_no.into(),
            invoice_date: invoice_date.into(),
            invoice_sum: None,
            verify_code: None,
            invoice_kind: None,
        }
    }
}
impl crate::ToFormData for VerifyVATInvoice {
    fn to_form_data(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        Default::default()
    }
}

impl crate::Request for VerifyVATInvoice {
    const METHOD: http::Method = http::Method::POST;

    const ACTION: &'static str = "VerifyVATInvoice";

    type Body = crate::Form<Self>;

    type ResponseWrap = crate::JsonResponseWrap<VerifyVATInvoiceResponse>;

    fn to_query_params(&self) -> Vec<(std::borrow::Cow<'static, str>, crate::QueryValue<'_>)> {
        let mut params = Vec::with_capacity(6);

        if let Some(f) = &self.invoice_code {
            params.push(("InvoiceCode".into(), (f).into()));
        }
        params.push(("InvoiceDate".into(), (&self.invoice_date).into()));

        if let Some(f) = &self.invoice_kind {
            params.push(("InvoiceKind".into(), (f).into()));
        }
        params.push(("InvoiceNo".into(), (&self.invoice_no).into()));

        if let Some(f) = &self.invoice_sum {
            params.push(("InvoiceSum".into(), (f).into()));
        }

        if let Some(f) = &self.verify_code {
            params.push(("VerifyCode".into(), (f).into()));
        }

        params
    }

    fn to_headers(&self) -> Vec<(std::borrow::Cow<'static, str>, String)> {
        Default::default()
    }

    fn to_body(self) -> Self::Body {
        crate::Form(self)
    }
}

/// * 当图片类型为通用文字识别高精版时（**Type=Advanced**），可通过本字段设置可选功能。
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct AdvancedConfig {
    /// - 是否需要成行返回功能。开启后会返回**RowInfo**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    #[serde(rename = "OutputRow")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_row: Option<bool>,
    /// - 是否需要分段功能。开启后会返回**ParagraphInfo**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    #[serde(rename = "OutputParagraph")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_paragraph: Option<bool>,
    /// - 是否需要输出表格识别结果，包含单元格信息。开启后会返回**TableInfo**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要识别表格时开启此参数。
    #[serde(rename = "OutputTable")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_table: Option<bool>,
    /// - 是否需要输出单字识别结果。开启后，**BlockInfo**字段中会返回**CharInfos**字段（详见返回参数说明）。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    #[serde(rename = "OutputCharInfo")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_char_info: Option<bool>,
    /// - 是否为无线表格或表格只有横线没有竖线。
    /// - true：无线表格；false：有线表格。
    /// - 默认值：false。
    /// - **请注意**：仅当**OutputTable=true**时，设置此参数才生效。
    #[serde(rename = "IsLineLessTable")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_line_less_table: Option<bool>,
    /// - 是否是手写表格。
    /// - true：是手写表格；false：不是手写表格。
    /// - 默认值：false。
    /// - **请注意**：仅当**OutputTable=true**时，设置此参数才生效。
    #[serde(rename = "IsHandWritingTable")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_hand_writing_table: Option<bool>,
    /// - 是否将识别的表格结果导出成 Excel，并以文件链接形式返回。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    /// - 文件链接有效期为一小时。
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要时开启此参数。
    #[serde(rename = "OutputTableExcel")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_table_excel: Option<bool>,
    /// - 是否将识别的表格结果导出成 Html 格式结果，并以文件链接形式返回。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    /// - 文件链接有效期为一小时。
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要时开启此参数。
    #[serde(rename = "OutputTableHtml")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_table_html: Option<bool>,
}

/// * 当图片类型为身份证时（**Type=IdCard**），可通过本字段设置可选功能。
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct TextIdCardConfig {
    /// - 是否需要身份证质量检测功能。
    /// - 身份证质量检测功能包含：是否翻拍，是否是复印件，完整度评分，整体质量分数。
    /// - true：需要；false：不需要。
    /// - 默认值：false。
    /// - **请注意**：开启此参数后，会增加接口的响应时间，请在需要身份证质量检测功能时开启此参数。
    #[serde(rename = "OutputIdCardQuality")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_id_card_quality: Option<bool>,
    #[serde(rename = "Llm_rec")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub llm_rec: Option<bool>,
}

/// * 当图片类型为国际身份证时（Type=**InternationalIdCard**），可通过本字段设置可选功能。
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct InternationalIdCardConfig {
    /// - 国家名称。
    /// - 支持的国家类型：India，Vietnam，Korea，Bangladesh。
    /// - 默认不需要传此参数，算法自动判断。
    /// - **请注意**：如果指定国家名称，接口响应时间更短。
    #[serde(rename = "Country")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<ConfigCountry>,
}

/// * 当图片类型为国际企业执照时（Type=**InternationalBusinessLicense**），可通过本字段设置可选功能。
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct LicenseConfig {
    /// * 国家名称。
    /// * 支持的国家类型：India，Korea。
    /// * 默认不需要传此参数，算法自动判断。
    /// * 请注意：如果指定国家名称，接口响应时间更短。
    #[serde(rename = "Country")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
}

/// * 当图片类型为通用多语言文字时（Type=**MultiLang**），可通过本字段设置可选功能。
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct LanConfig {
    /// - 支持的语言列表。
    /// - chn：中文，eng：英文，ja：日文，lading：拉丁，kor：韩文，sx：手写，tai：泰文，rus：俄文，mys：马来文，idn：印尼文，viet：越南文，ukr：乌克兰。
    /// - **请注意**：可以同时传多个语言参数，用逗号分隔。例如：Languages="eng,chn,lading"。但如果您确认图片的语言类型，建议传一种语言参数，算法识别效果更好。
    #[serde(rename = "Languages")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub languages: Option<String>,
}

/// * 当图片类型为表格时（Type=**Table**），可通过本字段设置可选功能。
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct TableConfig {
    /// * 是否是手写表格。
    /// * true：是手写表格；false：不是手写表格。
    /// * 默认值：false。
    #[serde(rename = "IsHandWritingTable")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_hand_writing_table: Option<bool>,
    /// * 是否为无线表格或表格只有横线没有竖线。
    /// * true：无线表格；false：有线表格。
    /// * 默认值：false。
    #[serde(rename = "IsLineLessTable")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_line_less_table: Option<bool>,
    /// * 是否将识别的表格结果导出成 Excel，并以文件链接形式返回。
    /// * true：需要；false：不需要。
    /// * 默认值：false。
    /// * 文件链接有效期为一小时。
    /// * **请注意**：开启此参数后，会增加接口的响应时间，请在需要时开启此参数。
    #[serde(rename = "OutputTableExcel")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_table_excel: Option<bool>,
    /// * 是否将识别的表格结果导出成 Html 格式结果，并以文件链接形式返回。
    /// * true：需要；false：不需要。
    /// * 默认值：false。
    /// * 文件链接有效期为一小时。
    /// * **请注意**：开启此参数后，会增加接口的响应时间，请在需要时开启此参数。
    #[serde(rename = "OutputTableHtml")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_table_html: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct ImagePoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 子图旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct ImageRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 子图宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 子图高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

/// * 结构化信息明细，字典类型。Key为字段名称，Value为此字段对应的识别结果（包含字段值、坐标、置信度等）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct KvDetails {
    /// Additional properties not explicitly defined in the schema
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, crate::Value>,
}

/// * 子图的结构化信息。
/// * 个人卡证、票据等类型图片会返回结构化信息。例如身份证图片，此字段会包含姓名、性别等信息。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct TextResponseDataSubImagesItemKvInfo {
    /// 子图所包含结构化信息的键值对数量。
    #[serde(rename = "KvCount")]
    pub kv_count: Option<i32>,
    /// * 结构化信息文字内容。字典类型，**键**为字段名称，**值**为字段对应的识别结果。
    /// * 不同图片类型（**Type**）的结构化字段不同。所有**Type**返回的结构化字段详见**返回结果补充说明**。
    #[serde(rename = "Data")]
    pub data: Option<String>,
    /// * 结构化信息明细，字典类型。Key为字段名称，Value为此字段对应的识别结果（包含字段值、坐标、置信度等）。
    #[serde(rename = "KvDetails")]
    pub kv_details: Option<KvDetails>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BlockPoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 文字块旋转矩形坐标（当 **OutputCoordinate="rectangle"** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BlockRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 矩形宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 矩形高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct CharPoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 单字旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct CharRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 矩形宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 矩形高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct CharInfo {
    /// 单字ID（编号从**0**开始）。
    #[serde(rename = "CharId")]
    pub char_id: Option<i32>,
    /// 单字内容。
    #[serde(rename = "CharContent")]
    pub char_content: Option<String>,
    /// 单字置信度（范围：0～100）。
    #[serde(rename = "CharConfidence")]
    pub char_confidence: Option<i32>,
    /// 单字四点坐标（当 **OutputCoordinate=“points”** 时返回）。
    #[serde(rename = "CharPoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub char_points: Vec<CharPoint>,
    /// 单字旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
    #[serde(rename = "CharRect")]
    pub char_rect: Option<CharRect>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BlockDetail {
    /// 文字块ID（编号从**0**开始）。
    #[serde(rename = "BlockId")]
    pub block_id: Option<i32>,
    /// 文字块顺时针旋转角度（范围：0～359）。
    #[serde(rename = "BlockAngle")]
    pub block_angle: Option<i32>,
    /// 文字块的文字内容。
    #[serde(rename = "BlockContent")]
    pub block_content: Option<String>,
    /// 文字块置信度（范围：0～100）。
    #[serde(rename = "BlockConfidence")]
    pub block_confidence: Option<i32>,
    /// 文字块四点坐标（当 **OutputCoordinate="points"** 时返回）。
    #[serde(rename = "BlockPoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub block_points: Vec<BlockPoint>,
    /// 文字块旋转矩形坐标（当 **OutputCoordinate="rectangle"** 时返回）。
    #[serde(rename = "BlockRect")]
    pub block_rect: Option<BlockRect>,
    /// 单字信息（当 **AdvancedConfig.OutputCharInfo=true** 时返回）。
    #[serde(rename = "CharInfos")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub char_infos: Vec<CharInfo>,
}

/// * 子图文字块信息。
/// * 当**Type**为**Advanced**、**General**、**MultiLang**、**Commerce**、**HandWriting**  时返回。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BlockInfo {
    /// 子图文字块数量。
    #[serde(rename = "BlockCount")]
    pub block_count: Option<i32>,
    /// 子图文字块信息明细。
    #[serde(rename = "BlockDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub block_details: Vec<BlockDetail>,
}

/// 表头信息。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct ItemHeader {
    /// 表头文字内容。
    #[serde(rename = "Contents")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub contents: Vec<String>,
    /// 文字块ID（编号从0开始）。
    #[serde(rename = "BlockId")]
    pub block_id: Option<i32>,
}

/// 表尾信息。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct ItemFooter {
    /// 表尾文字内容。
    #[serde(rename = "Contents")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub contents: Vec<String>,
    /// 文字块ID（编号从**0**开始）。
    #[serde(rename = "BlockId")]
    pub block_id: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct CellPoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 单元格旋转矩形坐标（当 **OutputCoordinate="rectangle"** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct CellRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 矩形宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 矩形高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct CellDetail {
    /// 单元格ID（编号从**0**开始）。
    #[serde(rename = "CellId")]
    pub cell_id: Option<i32>,
    /// 单元格文字内容。
    #[serde(rename = "CellContent")]
    pub cell_content: Option<String>,
    /// 单元格起始行数。第一个单元格位置为**0**。
    #[serde(rename = "RowStart")]
    pub row_start: Option<i32>,
    /// 单元格终止行数。第一个单元格位置为**0**。**RowStart=0** 且 **RowEnd=0** 表示此单元格只占据了第一行。
    #[serde(rename = "RowEnd")]
    pub row_end: Option<i32>,
    /// 单元格起始列数。第一个单元格位置为**0**。
    #[serde(rename = "ColumnStart")]
    pub column_start: Option<i32>,
    /// 单元格终止列数。第一个单元格位置为**0**。**ColumnStart=0** 且 **ColumnEnd=0** 表示此单元格只占据了第一列。
    #[serde(rename = "ColumnEnd")]
    pub column_end: Option<i32>,
    /// 此单元格所包含的文字块ID。
    #[serde(rename = "BlockList")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub block_list: Vec<i32>,
    /// 单元格四点坐标（当 **OutputCoordinate="points"** 时返回）。
    #[serde(rename = "CellPoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub cell_points: Vec<CellPoint>,
    /// 单元格旋转矩形坐标（当 **OutputCoordinate="rectangle"** 时返回）。
    #[serde(rename = "CellRect")]
    pub cell_rect: Option<CellRect>,
    /// 单元格顺时针旋转角度（范围：0～359）。
    #[serde(rename = "CellAngle")]
    pub cell_angle: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct TablePoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 表格旋转矩形坐标（当 **OutputCoordinate=“rectangle"** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct TableRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 矩形宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 矩形高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct TableDetail {
    /// 表格ID（编号从**0**开始）。
    #[serde(rename = "TableId")]
    pub table_id: Option<i32>,
    /// 表格行数。
    #[serde(rename = "RowCount")]
    pub row_count: Option<i32>,
    /// 表格列数。
    #[serde(rename = "ColumnCount")]
    pub column_count: Option<i32>,
    /// 表格单元格数量。
    #[serde(rename = "CellCount")]
    pub cell_count: Option<i32>,
    /// 表头信息。
    #[serde(rename = "Header")]
    pub header: Option<ItemHeader>,
    /// 表尾信息。
    #[serde(rename = "Footer")]
    pub footer: Option<ItemFooter>,
    /// 单元格信息明细。
    #[serde(rename = "CellDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub cell_details: Vec<CellDetail>,
    /// 表格四点坐标（当 **OutputCoordinate=“points"** 时返回）。
    #[serde(rename = "TablePoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub table_points: Vec<TablePoint>,
    /// 表格旋转矩形坐标（当 **OutputCoordinate=“rectangle"** 时返回）。
    #[serde(rename = "TableRect")]
    pub table_rect: Option<TableRect>,
}

/// 表格信息（当 **AdvancedConfig.OutputTable=true** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct TableInfo {
    /// 表格数量。
    #[serde(rename = "TableCount")]
    pub table_count: Option<i32>,
    /// 表格信息明细。
    #[serde(rename = "TableDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub table_details: Vec<TableDetail>,
    /// * 表格识别结果转成 Excel 后，导出的文件链接。
    /// * 有效期：1小时。
    #[serde(rename = "TableExcel")]
    pub table_excel: Option<String>,
    /// * 表格识别结果转成 Html 格式后，导出的文件链接。
    /// * 有效期：1小时。
    #[serde(rename = "TableHtml")]
    pub table_html: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct RowDetail {
    /// 行ID（编号从**0**开始）。
    #[serde(rename = "RowId")]
    pub row_id: Option<i32>,
    /// 行文字内容。
    #[serde(rename = "RowContent")]
    pub row_content: Option<String>,
    /// 此行所包含的文字块ID列表。
    #[serde(rename = "BlockList")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub block_list: Vec<i32>,
}

/// 子图行信息（当 **AdvancedConfig.OutputRow=true** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct RowInfo {
    /// 子图包含的行数。
    #[serde(rename = "RowCount")]
    pub row_count: Option<i32>,
    /// 子图行信息明细。
    #[serde(rename = "RowDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub row_details: Vec<RowDetail>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct ParagraphDetail {
    /// 段落ID（编号从**0**开始）。
    #[serde(rename = "ParagraphId")]
    pub paragraph_id: Option<i32>,
    /// 段落文字内容。
    #[serde(rename = "ParagraphContent")]
    pub paragraph_content: Option<String>,
    /// 此段所包含的文字块ID列表。
    #[serde(rename = "BlockList")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub block_list: Vec<i32>,
}

/// 子图段落信息（当 **AdvancedConfig.OutputParagraph=true** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct ParagraphInfo {
    /// 子图所包含段落数量。
    #[serde(rename = "ParagraphCount")]
    pub paragraph_count: Option<i32>,
    /// 子图段落信息明细。
    #[serde(rename = "ParagraphDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub paragraph_details: Vec<ParagraphDetail>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct QrCodePoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 二维码旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct QrCodeRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 矩形宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 矩形高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct QrCodeDetail {
    /// 二维码内容。
    #[serde(rename = "Data")]
    pub data: Option<String>,
    /// 二维码四点坐标（当 **OutputCoordinate=“points”** 时返回）。
    #[serde(rename = "QrCodePoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub qr_code_points: Vec<QrCodePoint>,
    /// 二维码旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
    #[serde(rename = "QrCodeRect")]
    pub qr_code_rect: Option<QrCodeRect>,
    /// QrCode旋转角度（范围：0～359）。
    #[serde(rename = "QrCodeAngle")]
    pub qr_code_angle: Option<i32>,
}

/// 子图二维码信息（当 **OutputQrcode=true** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct QrCodeInfo {
    /// 子图二维码数量。
    #[serde(rename = "QrCodeCount")]
    pub qr_code_count: Option<i32>,
    /// 子图二维码信息明细。
    #[serde(rename = "QrCodeDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub qr_code_details: Vec<QrCodeDetail>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BarCodePoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 条形码旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BarCodeRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 矩形宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 矩形高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BarCodeDetail {
    /// 条形码类型。支持的类型如下：
    /// * Codabar
    /// * Code39
    /// * Code93
    /// * Code128
    #[serde(rename = "Type")]
    pub r#type: Option<String>,
    /// 条形码内容。
    #[serde(rename = "Data")]
    pub data: Option<String>,
    /// 条形码四点坐标（当 **OutputCoordinate=“points”** 时返回）。
    #[serde(rename = "BarCodePoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub bar_code_points: Vec<BarCodePoint>,
    /// 条形码旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
    #[serde(rename = "BarCodeRect")]
    pub bar_code_rect: Option<BarCodeRect>,
    /// 条形码顺时针旋转角度（范围：0～359）。
    #[serde(rename = "BarCodeAngle")]
    pub bar_code_angle: Option<i32>,
}

/// 子图条形码信息（当 **OutputBarCode=true** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct BarCodeInfo {
    /// 子图条形码数量。
    #[serde(rename = "BarCodeCount")]
    pub bar_code_count: Option<i32>,
    /// 条形码信息明细。
    #[serde(rename = "BarCodeDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub bar_code_details: Vec<BarCodeDetail>,
}

/// 子图包含的图案信息（当 **OutputFigure=true** 时返回）。字典类型，键为图案类型，值为此类型图案的信息。支持的图案类型如下：
/// * blicense_title：营业执照标题
/// * national_emblem：国徽
/// * face：人脸
/// * finger_print：指纹
/// * signature：签名区域
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct FigureInfo {
    /// Additional properties not explicitly defined in the schema
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, crate::Value>,
}

/// 子图印章识别结果，字典类型，键为字段名称，值为对应字段的识别结果。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct ItemData {
    /// 进出口企业代码。
    #[serde(rename = "CompanyId")]
    pub company_id: Option<String>,
    /// 组织名。
    #[serde(rename = "OrganizationName")]
    pub organization_name: Option<String>,
    /// 防伪编码。
    #[serde(rename = "AntiFakeCode")]
    pub anti_fake_code: Option<String>,
    /// 其它文字。
    #[serde(rename = "OtherText")]
    pub other_text: Option<String>,
    /// 上环文字。
    #[serde(rename = "TopText")]
    pub top_text: Option<String>,
    /// 英文组织名。
    #[serde(rename = "OrganizationNameEng")]
    pub organization_name_eng: Option<String>,
    /// 纳税人识别号。
    #[serde(rename = "TaxpayerId")]
    pub taxpayer_id: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct StampPoint {
    /// 顶点横坐标。
    #[serde(rename = "X")]
    pub x: Option<i32>,
    /// 顶点纵坐标。
    #[serde(rename = "Y")]
    pub y: Option<i32>,
}

/// 印章旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct StampRect {
    /// 矩形中心点横坐标。
    #[serde(rename = "CenterX")]
    pub center_x: Option<i32>,
    /// 矩形中心点纵坐标。
    #[serde(rename = "CenterY")]
    pub center_y: Option<i32>,
    /// 矩形宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 矩形高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct StampDetail {
    /// 子图印章识别结果，字典类型，键为字段名称，值为对应字段的识别结果。
    #[serde(rename = "Data")]
    pub data: Option<ItemData>,
    /// 印章四点坐标（当 **OutputCoordinate=“points”** 时返回）。
    #[serde(rename = "StampPoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub stamp_points: Vec<StampPoint>,
    /// 印章旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
    #[serde(rename = "StampRect")]
    pub stamp_rect: Option<StampRect>,
    /// 矩形顺时针旋转角度（范围：0～359）。
    #[serde(rename = "StampAngle")]
    pub stamp_angle: Option<i32>,
}

/// 子图印章信息（当 **OutputStamp=true** 时返回）。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct StampInfo {
    /// 子图印章数量。
    #[serde(rename = "StampCount")]
    pub stamp_count: Option<i32>,
    /// 印章信息明细。
    #[serde(rename = "StampDetails")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub stamp_details: Vec<StampDetail>,
}

/// 子图质量检测信息。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct QualityInfo {
    /// 是否为复印件
    #[serde(rename = "IsCopy")]
    pub is_copy: Option<bool>,
    /// 是否是翻拍。仅支持身份证类型图片（**Type=IdCard**）。
    #[serde(rename = "IsReshoot")]
    pub is_reshoot: Option<bool>,
    /// 完整度评分。仅支持身份证类型图片（**Type=IdCard**）。
    #[serde(rename = "CompletenessScore")]
    pub completeness_score: Option<f32>,
    /// 整体质量分数。仅支持身份证类型图片（**Type=IdCard**）。
    #[serde(rename = "QualityScore")]
    pub quality_score: Option<f32>,
    /// 篡改分数。仅支持身份证类型图片（**Type=IdCard**）。
    #[serde(rename = "TamperScore")]
    pub tamper_score: Option<f32>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct TextResponseDataSubImage {
    /// 子图ID（编号从**0**开始）。
    #[serde(rename = "SubImageId")]
    pub sub_image_id: Option<i32>,
    /// 子图类型（例如**身份证正面**、**增值税发票**等）。
    #[serde(rename = "Type")]
    pub r#type: Option<String>,
    /// 子图顺时针旋转角度（范围：0～359度）。
    #[serde(rename = "Angle")]
    pub angle: Option<i32>,
    /// 子图四点坐标（当 **OutputCoordinate=“points”** 时返回）。
    #[serde(rename = "SubImagePoints")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub sub_image_points: Vec<ImagePoint>,
    /// 子图旋转矩形坐标（当 **OutputCoordinate=“rectangle”** 时返回）。
    #[serde(rename = "SubImageRect")]
    pub sub_image_rect: Option<ImageRect>,
    /// * 子图的结构化信息。
    /// * 个人卡证、票据等类型图片会返回结构化信息。例如身份证图片，此字段会包含姓名、性别等信息。
    #[serde(rename = "KvInfo")]
    pub kv_info: Option<TextResponseDataSubImagesItemKvInfo>,
    /// * 子图文字块信息。
    /// * 当**Type**为**Advanced**、**General**、**MultiLang**、**Commerce**、**HandWriting**  时返回。
    #[serde(rename = "BlockInfo")]
    pub block_info: Option<BlockInfo>,
    /// 表格信息（当 **AdvancedConfig.OutputTable=true** 时返回）。
    #[serde(rename = "TableInfo")]
    pub table_info: Option<TableInfo>,
    /// 子图行信息（当 **AdvancedConfig.OutputRow=true** 时返回）。
    #[serde(rename = "RowInfo")]
    pub row_info: Option<RowInfo>,
    /// 子图段落信息（当 **AdvancedConfig.OutputParagraph=true** 时返回）。
    #[serde(rename = "ParagraphInfo")]
    pub paragraph_info: Option<ParagraphInfo>,
    /// 子图二维码信息（当 **OutputQrcode=true** 时返回）。
    #[serde(rename = "QrCodeInfo")]
    pub qr_code_info: Option<QrCodeInfo>,
    /// 子图条形码信息（当 **OutputBarCode=true** 时返回）。
    #[serde(rename = "BarCodeInfo")]
    pub bar_code_info: Option<BarCodeInfo>,
    /// 子图包含的图案信息（当 **OutputFigure=true** 时返回）。字典类型，键为图案类型，值为此类型图案的信息。支持的图案类型如下：
    /// * blicense_title：营业执照标题
    /// * national_emblem：国徽
    /// * face：人脸
    /// * finger_print：指纹
    /// * signature：签名区域
    #[serde(rename = "FigureInfo")]
    pub figure_info: Option<FigureInfo>,
    /// 子图印章信息（当 **OutputStamp=true** 时返回）。
    #[serde(rename = "StampInfo")]
    pub stamp_info: Option<StampInfo>,
    /// 子图质量检测信息。
    #[serde(rename = "QualityInfo")]
    pub quality_info: Option<QualityInfo>,
}

/// 识别结果。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct TextResponseData {
    /// 原图高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
    /// 原图宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 图片包含的所有文字汇总。
    #[serde(rename = "Content")]
    pub content: Option<String>,
    /// 图片包含的子图数量。
    #[serde(rename = "SubImageCount")]
    pub sub_image_count: Option<i32>,
    /// 图片包含的子图信息。
    #[serde(rename = "SubImages")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub sub_images: Vec<TextResponseDataSubImage>,
    /// XML格式返回结果。
    #[serde(rename = "XmlResult")]
    pub xml_result: Option<String>,
    /// 算法版本号。
    #[serde(rename = "AlgoVersion")]
    pub algo_version: Option<String>,
    /// Debug信息（不为空时才返回此字段）。
    #[serde(rename = "DebugInfo")]
    pub debug_info: Option<String>,
    /// 算法服务器信息列表（不为空时才返回此字段）。
    #[serde(rename = "AlgoServer")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub algo_server: Vec<String>,
    /// 是否是混贴类型。
    #[serde(rename = "IsMixedMode")]
    pub is_mixed_mode: Option<bool>,
    /// PDF/OFD页码（从**1**开始）。
    #[serde(rename = "PageNo")]
    pub page_no: Option<i32>,
    /// * 卡证、票据类型图片的结构化信息转成 Excel 格式后，导出的文件链接。
    /// * 有效期：1小时。
    #[serde(rename = "KvExcelUrl")]
    pub kv_excel_url: Option<String>,
}

/// * 子图的结构化信息。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct StructureResponseDataSubImagesItemKvInfo {
    /// 子图所包含结构化信息的键值对数量。
    #[serde(rename = "KvCount")]
    pub kv_count: Option<i32>,
    /// * 结构化信息文字内容。字典类型，键为字段名称，值为字段对应的识别结果。
    #[serde(rename = "Data")]
    pub data: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct StructureResponseDataSubImage {
    /// 子图ID（编号从**0**开始）。
    #[serde(rename = "SubImageId")]
    pub sub_image_id: Option<i32>,
    /// 子图顺时针旋转角度（范围：0～359度）。
    #[serde(rename = "Angle")]
    pub angle: Option<i32>,
    /// * 子图的结构化信息。
    #[serde(rename = "KvInfo")]
    pub kv_info: Option<StructureResponseDataSubImagesItemKvInfo>,
}

/// 识别结果。
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct StructureResponseData {
    /// 原图高度。
    #[serde(rename = "Height")]
    pub height: Option<i32>,
    /// 原图宽度。
    #[serde(rename = "Width")]
    pub width: Option<i32>,
    /// 图片包含的子图数量。
    #[serde(rename = "SubImageCount")]
    pub sub_image_count: Option<i32>,
    /// 图片包含的子图信息。
    #[serde(rename = "SubImages")]
    #[serde(default)]
    #[serde(deserialize_with = "crate::deserialize_default_on_null")]
    pub sub_images: Vec<StructureResponseDataSubImage>,
}

/// Enum type marshalled as String
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum TextType {
    #[serde(rename = "Advanced")]
    Advanced,
    #[serde(rename = "General")]
    General,
    #[serde(rename = "HandWriting")]
    HandWriting,
    #[serde(rename = "Commerce")]
    Commerce,
    #[serde(rename = "MultiLang")]
    MultiLang,
    #[serde(rename = "IdCard")]
    IdCard,
    #[serde(rename = "InternationalPassport")]
    InternationalPassport,
    #[serde(rename = "HouseholdHead")]
    HouseholdHead,
    #[serde(rename = "HouseholdResident")]
    HouseholdResident,
    #[serde(rename = "EstateCertification")]
    EstateCertification,
    #[serde(rename = "BankCard")]
    BankCard,
    #[serde(rename = "BirthCertification")]
    BirthCertification,
    #[serde(rename = "ChinesePassport")]
    ChinesePassport,
    #[serde(rename = "PermitToHK_MO_TW")]
    PermitToHkMoTw,
    #[serde(rename = "PermitToMainland")]
    PermitToMainland,
    #[serde(rename = "HKIdCard")]
    HkIdCard,
    #[serde(rename = "SocialSecurityCard")]
    SocialSecurityCard,
    #[serde(rename = "InternationalIdCard")]
    InternationalIdCard,
    #[serde(rename = "Stamp")]
    Stamp,
    #[serde(rename = "Invoice")]
    Invoice,
    #[serde(rename = "CarInvoice")]
    CarInvoice,
    #[serde(rename = "QuotaInvoice")]
    QuotaInvoice,
    #[serde(rename = "AirItinerary")]
    AirItinerary,
    #[serde(rename = "TrainTicket")]
    TrainTicket,
    #[serde(rename = "TaxiInvoice")]
    TaxiInvoice,
    #[serde(rename = "RollTicket")]
    RollTicket,
    #[serde(rename = "BankAcceptance")]
    BankAcceptance,
    #[serde(rename = "BusShipTicket")]
    BusShipTicket,
    #[serde(rename = "NonTaxInvoice")]
    NonTaxInvoice,
    #[serde(rename = "CommonPrintedInvoice")]
    CommonPrintedInvoice,
    #[serde(rename = "HotelConsume")]
    HotelConsume,
    #[serde(rename = "PaymentRecord")]
    PaymentRecord,
    #[serde(rename = "PurchaseRecord")]
    PurchaseRecord,
    #[serde(rename = "RideHailingItinerary")]
    RideHailingItinerary,
    #[serde(rename = "ShoppingReceipt")]
    ShoppingReceipt,
    #[serde(rename = "TollInvoice")]
    TollInvoice,
    #[serde(rename = "TaxClearanceCertificate")]
    TaxClearanceCertificate,
    #[serde(rename = "UsedCarInvoice")]
    UsedCarInvoice,
    #[serde(rename = "VehicleLicense")]
    VehicleLicense,
    #[serde(rename = "DrivingLicense")]
    DrivingLicense,
    #[serde(rename = "LicensePlateNumber")]
    LicensePlateNumber,
    #[serde(rename = "MixedInvoice")]
    MixedInvoice,
    #[serde(rename = "BusinessLicense")]
    BusinessLicense,
    #[serde(rename = "CarVinCode")]
    CarVinCode,
    #[serde(rename = "InternationalBusinessLicense")]
    InternationalBusinessLicense,
    #[serde(rename = "WayBill")]
    WayBill,
    #[serde(rename = "FoodProduceLicense")]
    FoodProduceLicense,
    #[serde(rename = "FoodManagementLicense")]
    FoodManagementLicense,
    #[serde(rename = "MedicalDeviceManageLicense")]
    MedicalDeviceManageLicense,
    #[serde(rename = "MedicalDeviceProduceLicense")]
    MedicalDeviceProduceLicense,
    #[serde(rename = "ClassIIMedicalDeviceManageLicense")]
    ClassIiMedicalDeviceManageLicense,
    #[serde(rename = "CosmeticProduceLicense")]
    CosmeticProduceLicense,
    #[serde(rename = "VehicleRegistration")]
    VehicleRegistration,
    #[serde(rename = "VehicleCertification")]
    VehicleCertification,
    #[serde(rename = "QrCode")]
    QrCode,
    #[serde(rename = "BarCode")]
    BarCode,
    #[serde(rename = "BankAccountPermit")]
    BankAccountPermit,
    #[serde(rename = "Table")]
    Table,
    #[serde(rename = "TrademarkCertificate")]
    TrademarkCertificate,
}

impl Default for TextType {
    fn default() -> Self {
        Self::Advanced
    }
}

impl TextType {
    /// Returns the string value of this enum variant as used in the API.
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Advanced => "Advanced",
            Self::General => "General",
            Self::HandWriting => "HandWriting",
            Self::Commerce => "Commerce",
            Self::MultiLang => "MultiLang",
            Self::IdCard => "IdCard",
            Self::InternationalPassport => "InternationalPassport",
            Self::HouseholdHead => "HouseholdHead",
            Self::HouseholdResident => "HouseholdResident",
            Self::EstateCertification => "EstateCertification",
            Self::BankCard => "BankCard",
            Self::BirthCertification => "BirthCertification",
            Self::ChinesePassport => "ChinesePassport",
            Self::PermitToHkMoTw => "PermitToHK_MO_TW",
            Self::PermitToMainland => "PermitToMainland",
            Self::HkIdCard => "HKIdCard",
            Self::SocialSecurityCard => "SocialSecurityCard",
            Self::InternationalIdCard => "InternationalIdCard",
            Self::Stamp => "Stamp",
            Self::Invoice => "Invoice",
            Self::CarInvoice => "CarInvoice",
            Self::QuotaInvoice => "QuotaInvoice",
            Self::AirItinerary => "AirItinerary",
            Self::TrainTicket => "TrainTicket",
            Self::TaxiInvoice => "TaxiInvoice",
            Self::RollTicket => "RollTicket",
            Self::BankAcceptance => "BankAcceptance",
            Self::BusShipTicket => "BusShipTicket",
            Self::NonTaxInvoice => "NonTaxInvoice",
            Self::CommonPrintedInvoice => "CommonPrintedInvoice",
            Self::HotelConsume => "HotelConsume",
            Self::PaymentRecord => "PaymentRecord",
            Self::PurchaseRecord => "PurchaseRecord",
            Self::RideHailingItinerary => "RideHailingItinerary",
            Self::ShoppingReceipt => "ShoppingReceipt",
            Self::TollInvoice => "TollInvoice",
            Self::TaxClearanceCertificate => "TaxClearanceCertificate",
            Self::UsedCarInvoice => "UsedCarInvoice",
            Self::VehicleLicense => "VehicleLicense",
            Self::DrivingLicense => "DrivingLicense",
            Self::LicensePlateNumber => "LicensePlateNumber",
            Self::MixedInvoice => "MixedInvoice",
            Self::BusinessLicense => "BusinessLicense",
            Self::CarVinCode => "CarVinCode",
            Self::InternationalBusinessLicense => "InternationalBusinessLicense",
            Self::WayBill => "WayBill",
            Self::FoodProduceLicense => "FoodProduceLicense",
            Self::FoodManagementLicense => "FoodManagementLicense",
            Self::MedicalDeviceManageLicense => "MedicalDeviceManageLicense",
            Self::MedicalDeviceProduceLicense => "MedicalDeviceProduceLicense",
            Self::ClassIiMedicalDeviceManageLicense => "ClassIIMedicalDeviceManageLicense",
            Self::CosmeticProduceLicense => "CosmeticProduceLicense",
            Self::VehicleRegistration => "VehicleRegistration",
            Self::VehicleCertification => "VehicleCertification",
            Self::QrCode => "QrCode",
            Self::BarCode => "BarCode",
            Self::BankAccountPermit => "BankAccountPermit",
            Self::Table => "Table",
            Self::TrademarkCertificate => "TrademarkCertificate",
        }
    }
}

impl std::fmt::Display for TextType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a TextType> for crate::QueryValue<'a> {
    fn from(value: &'a TextType) -> Self {
        crate::QueryValue::from(value.as_str())
    }
}

/// Enum type marshalled as String
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum ConfigCountry {
    #[serde(rename = "India")]
    India,
    #[serde(rename = "Korea")]
    Korea,
    #[serde(rename = "Vietnam")]
    Vietnam,
    #[serde(rename = "Bangladesh")]
    Bangladesh,
}

impl Default for ConfigCountry {
    fn default() -> Self {
        Self::India
    }
}

impl ConfigCountry {
    /// Returns the string value of this enum variant as used in the API.
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::India => "India",
            Self::Korea => "Korea",
            Self::Vietnam => "Vietnam",
            Self::Bangladesh => "Bangladesh",
        }
    }
}

impl std::fmt::Display for ConfigCountry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ConfigCountry> for crate::QueryValue<'a> {
    fn from(value: &'a ConfigCountry) -> Self {
        crate::QueryValue::from(value.as_str())
    }
}

/// Enum type marshalled as String
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum HandWriting {
    #[serde(rename = "true")]
    True,
    #[serde(rename = "false")]
    False,
}

impl Default for HandWriting {
    fn default() -> Self {
        Self::True
    }
}

impl HandWriting {
    /// Returns the string value of this enum variant as used in the API.
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::True => "true",
            Self::False => "false",
        }
    }
}

impl std::fmt::Display for HandWriting {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HandWriting> for crate::QueryValue<'a> {
    fn from(value: &'a HandWriting) -> Self {
        crate::QueryValue::from(value.as_str())
    }
}

/// Enum type marshalled as String
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum IdcardCountry {
    /// India
    #[serde(rename = "India")]
    India,
    /// Vietnam
    #[serde(rename = "Vietnam")]
    Vietnam,
    /// Korea
    #[serde(rename = "Korea")]
    Korea,
    /// Bangladesh
    #[serde(rename = "Bangladesh")]
    Bangladesh,
}

impl Default for IdcardCountry {
    fn default() -> Self {
        Self::India
    }
}

impl IdcardCountry {
    /// Returns the string value of this enum variant as used in the API.
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::India => "India",
            Self::Vietnam => "Vietnam",
            Self::Korea => "Korea",
            Self::Bangladesh => "Bangladesh",
        }
    }
}

impl std::fmt::Display for IdcardCountry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a IdcardCountry> for crate::QueryValue<'a> {
    fn from(value: &'a IdcardCountry) -> Self {
        crate::QueryValue::from(value.as_str())
    }
}

/// Enum type marshalled as String
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum LicenseCountry {
    #[serde(rename = "India")]
    India,
    #[serde(rename = "Korea")]
    Korea,
}

impl Default for LicenseCountry {
    fn default() -> Self {
        Self::India
    }
}

impl LicenseCountry {
    /// Returns the string value of this enum variant as used in the API.
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::India => "India",
            Self::Korea => "Korea",
        }
    }
}

impl std::fmt::Display for LicenseCountry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseCountry> for crate::QueryValue<'a> {
    fn from(value: &'a LicenseCountry) -> Self {
        crate::QueryValue::from(value.as_str())
    }
}

/// #### 图片类型（Type）对应的KV信息字段说明。所有KV字段都是String类型。
/// |Type | 类型描述 | 返回KV信息字段说明|
/// |-----|-----|--|
/// |IdCard | 身份证 | <ul> <li> 正面字段：<ul> <li> name：姓名 </li> <li> sex：性别 </li> <li> ethnicity：民族 </li> <li> birthDate：出生日期 </li> <li> address：住址 </li> <li> idNumber：身份证号码 </li> </ul> </li> <li> 背面字段：<ul> <li> issueAuthority：签发机关 </li> <li> validPeriod：有效期限 </li> </ul> </li>  </ul> |
/// |BankCard | 银行卡 | <ul> <li> cardType：卡种 </li> <li> bankName：银行名称 </li> <li> cardNumber：银行卡号 </li> <li> validToDate：有效期限 </li> </ul> |
/// |InternationalPassport | 国际护照 | <ul> <li> passportType：证件类型 </li> <li> surname：姓 </li> <li> givenName：名 </li> <li> passportNumber：护照号码 </li> <li> nationality：国家码 </li> <li> nameEn：英文姓名 </li> <li> name：非英文姓名 </li> <li> sex：性别 </li> <li> birthPlaceEn：出生地 </li> <li> birthPlace：非英文出生地 </li> <li> country：国籍 </li> <li> validToDate：有效期至 </li> <li> birthDate：出生日期 </li> <li> birthDateYmd：出生日期（年月日）</li> <li> issueDateYmd：签发日期 </li> <li> issuePlaceEn：签发地 </li> <li> issuePlace：非英文签发地 </li> <li> issueAuthorityEn：签发机关 </li> <li> issueAuthority：非英文签发机关 </li> <li> idNumber：身份号 </li> <li> mrzLine1：机读码一 </li> <li> mrzLine2：机读码二 </li> </ul> |
/// |ChinesePassport | 中国护照 | <ul> <li> passportType：证件类型 </li> <li> countryCode：国家码 </li> <li> passportNumber：护照号码 </li> <li> nameEn：英文姓名 </li> <li> name：中文姓名 </li> <li> sex：性别 </li> <li> birthPlace：出生地 </li> <li> nationality：国籍 </li> <li> issuePlace：签发地 </li> <li> issueAuthority：签发机关 </li> <li> mrzLine1：机读码一 </li> <li> mrzLine2：机读码二 </li> <li> validToDate：有效期至 </li> <li> birthDate：出生日期 </li> <li> issueDate：签发日期 </li>  </ul> |
/// |SocialSecurityCard | 社保卡 | <ul> <li> bankAccount：银行账号 </li> <li> cardNumber：社保保障卡号 </li> <li> idNumber：社会保障号码 </li> <li> issueDate：发卡日期 </li> <li> name：姓名 </li> <li> title：标题 </li> <li> validPeriod：有效期限 </li> </ul> |
/// |PermitToHK_MO_TW | 往来港澳台通行证 | <ul> <li> permitType：证件类别 </li> <li> nameCn：中文姓名 </li> <li> nameEn：英文姓名 </li> <li> birthDate：出生日期 </li> <li> sex：性别 </li> <li> validPeriod：有效期限 </li> <li> issueAuthority：签发机关 </li> <li> issuePlace：签发地 </li> <li> permitNumber：证件号码 </li> <li> mrzCode：机读码 </li>  </ul> |
/// |PermitToMainland | 来往中国大陆（内地）通行证 | <ul> <li> birthDate：出生日期 </li> <li> issueAuthority：签发机关 </li> <li> issueCount：	签发次数 </li> <li> issuePlace：签发地点 </li> <li> nameCn：中文姓名 </li> <li> nameEn：英文姓名 </li> <li> permitNumber：证件号码 </li> <li> permitType：证件类别 </li> <li> sex：性别 </li> <li> validPeriod：有效期限 </li>  </ul> |
/// |HouseholdHead | 户口本户首页 | <ul> <li> Registrar：承办人签章 </li> <li> address：住址 </li> <li> householdNumber：	户号 </li> <li> householdType：户别 </li> <li> householderCommunity：户主社区 </li> <li> householderName：户主姓名 </li> <li> issueDate：签发日期 </li> <li> sectionNo：地段号 </li> </ul> |
/// |HouseholdResident | 户口本常住人口页 | <ul> <li> birthDate：出生日期 </li> <li> birthPlace：出生地 </li> <li> bloodGroup：血型 </li> <li> educationalDegree：文化程度 </li> <li> employer：服务处所 </li> <li> ethnicity：民族 </li> <li> formerName：曾用名 </li> <li> householdNumber：户号 </li> <li> idCardNumber：身份证编号 </li> <li> immigratedToCityInfo：何时何地迁来本市 </li> <li> immigratedToResidenceInfo：何时由何地迁来本址 </li> <li> maritalStatus：婚姻状况 </li> <li> militaryServiceStatus：兵役状况 </li> <li> name：姓名 </li> <li> nativePlace：籍贯 </li> <li> occupation：职业 </li> <li> otherResidence：本市其他住址 </li> <li> registrar：承办人签章 </li> <li> registrationDate：登记日期 </li> <li> relation：与户主关系 </li> <li> religious：	宗教信仰 </li> <li> sex：性别 </li> <li> stature：身高 </li> </ul> |
/// |EstateCertification | 不动产权证 | <ul> <li> area：面积 </li> <li> certificateNumber：证号 </li> <li> mutualOwnershipState：	共有情况 </li> <li> obligee：权利人 </li> <li> location：坐落地址 </li> <li> unitNumber：不动产单元号 </li> <li> rightType：权利类型 </li> <li> rightProperty：权利性质 </li> <li> usage：用途 </li> <li> serviceLife：使用期限 </li> <li> otherState：权利其他状况 </li> <li> buildingArea：房屋建筑面积 </li> </ul> |
/// |BirthCertification | 出生证明 | <ul> <li> neonatalName：新生儿姓名 </li> <li> sex：性别 </li> <li> birthTime：出生时间 </li> <li> gestationalAge：出生孕周 </li> <li> birthWeight：	出生体重 </li> <li> birthLength：出生身长 </li> <li> birthPlace：出生地 </li> <li> medicalInstitutions：医疗机构名称 </li> <li> motherName：母亲姓名 </li> <li> motherAge：母亲年龄 </li> <li> motherNationality：母亲国籍 </li> <li> motherEthnicity：母亲民族 </li> <li> motherAddress：母亲住址 </li> <li> motherIdCardNumber：母亲有效身份证件号 </li> <li> fatherName：父亲姓名 </li> <li> fatherAge：父亲年龄 </li> <li> fatherNationality：父亲国籍 </li> <li> fatherEthnicity：父亲民族 </li> <li> fatherAddress：父亲住址 </li> <li> fatherIdCardNumber：	父亲有效身份证件号 </li> <li> issueAuthority：签发机构 </li> <li> issueDate：签发日期 </li> <li> certificateNumber：编号 </li> </ul> |
/// |HKIdCard | 中国香港身份证 | <ul> <li> birthDate：出生日期 </li> <li> firstIssuedDate：首次签发日期 </li> <li> idNumber：身份证号码 </li> <li> issuedCode：签发标志 </li> <li> issuedDate：签发日期 </li> <li> nameCn：	中文姓名 </li> <li> nameCode：姓名电码 </li> <li> nameEn：英文姓名 </li> <li> sex：性别 </li> </ul> |
/// |InternationalIdCard | 国际身份证 | <ul> <li> 印度身份证正面字段：<ul> <li> name：本国姓名</li> <li> nameEn：英文姓名</li> <li> birthDate：出生日期 </li> <li> sex：性别 </li> <li> cardNumber：证件号码</li> <li> virtualNumber：虚拟号码 </li> </ul> </li> <li> 印度身份证反面字段：<ul> <li> address：本国地址 </li> <li> addressEn：英文地址 </li> <li> cardNumber：证件号码 </li> <li> virtualNumber：虚拟号码 </li> </ul> </li> <li> 印度纳税人证件字段： <ul> <li> birthDate：生日 </li> <li> fatherName：父亲姓名 </li> <li> name：姓名 </li> <li> taxId：	税号 </li> </ul> </li> <li> 越南身份证正面字段：<ul> <li> birthDate：	出生日期 </li> <li> validToDate：有效期至 </li> <li> residence：居住地</li> <li> cardType：证件类型</li> <li> placeOfAncestry：原籍地 </li> <li> cardNumber：证件号码 </li> <li> name：姓名 </li> <li> sex：性别</li> <li> nationality：国籍 </li> </ul> </li> <li> 越南身份证反面字段：<ul> <li> issuer：签发人 </li> <li> mrzLine1：机读码一 </li> <li> mrzLine2：机读码二 </li> <li> mrzLine3：机读码三 </li> <li> personalCharacteristics：身份识别特征 </li> <li> issueDate：签发日期 </li> </ul> </li> <li> 韩国身份证字段：<ul> <li> name：本国姓名 </li> <li> nameChn：中文姓名 </li> <li> cardNumber：证件号码 </li> <li> address：住址 </li> <li> issueDate：签发日期 </li> <li> issuer：签发人 </li> </ul> </li> <li>孟加拉国身份证字段：<ul> <li>name：本国姓名 </li> <li>nameEn：英文姓名 </li> <li>fatherName：父亲姓名 </li> <li>motherName：母亲姓名 </li> <li>birthDate：出生日期 </li> <li>cardNumber：	身份证号 </li> </ul> </li> </ul> |
/// |Stamp| 公章 | <ul> <li> companyId：进出口企业代码</li> <li> organizationName：组织名</li> <li> antiFakeCode：防伪编码</li> <li> otherText：其它文字</li> <li> topText：上环文字</li> <li> organizationNameEng：英文组织名 </li> <li> taxpayerId：纳税人识别号 </li> </ul>|   
/// |Invoice| 增值税发票 | <ul> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> invoiceDate：开票日期 </li> <li> machineCode：机器编码 </li> <li> checkCode：校验码 </li> <li> purchaserName：受票方名称 </li> <li> passwordArea：密码区 </li> <li> invoiceAmountPreTax：不含税金额 </li> <li> invoiceTax：发票税额 </li> <li> totalAmountInWords：大写金额 </li> <li> totalAmount：发票金额 </li> <li> sellerName：销售方名称 </li> <li> sellerTaxNumber：销售方税号 </li> <li> sellerContactInfo：销售方地址、电话 </li> <li> sellerBankAccountInfo：销售方开户行、账号 </li> <li> drawer：开票人 </li> <li> title：标题 </li> <li> invoiceType：发票类型（电子普通发票、电子专用发票、专用发票、普通发票、通用发票） </li> <li> formType：联次 </li> <li> printedInvoiceCode：机打发票代码 </li> <li> printedInvoiceNumber：机打发票号码 </li> <li> purchaserBankAccountInfo：受票方开户行、账号 </li> <li> purchaserContactInfo：受票方地址、电话 </li> <li> purchaserTaxNumber：受票方税号 </li> <li> recipient：收款人 </li> <li> remarks：备注 </li> <li> reviewer：复核人 </li> <li> specialTag：特殊标识信息 </li> <li> invoiceDetails：发票详单 </li> </ul>|   
/// |CarInvoice| 机动车销售统一发票 | <ul> <li> taxCode：税控码 </li> <li> invoiceDate：开票日期 </li> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> machineCode：机器编号 </li> <li> purchaserName：购买方名称 </li> <li> purchaseCode：购买方身份证号码/组织机构代码 </li> <li> vehicleType：车辆类型 </li> <li> brandMode：厂牌型号 </li> <li> origin：产地 </li> <li> certificateNumber：合格证号 </li> <li> importCertificateNumber：进口证明书号 </li> <li> commodityInspectionNumber：商检单号 </li> <li> engineNumber：发动机号码 </li> <li> vinCode：车辆识别代号/车架号码 </li> <li> invoiceAmountCn：价税合计（大写） </li> <li> invoiceAmount：价税合计（小写） </li> <li> sellerName：销货单位名称 </li> <li> sellerContact：销货单位电话 </li> <li> sellerTaxNumber：销货单位纳税人识别号 </li> <li> sellerBankAccount：销货单位账号 </li> <li> sellerAddress：销货单位地址 </li> <li> sellerDepositaryBank：销货单位开户银行 </li> <li> taxRate：增值税税率或征收率 </li> <li> tax：增值税税额 </li> <li> taxAuthoritiesInfo：主管税务机关及代码 </li> <li> taxAuthoritiesName：主管税务机关 </li> <li> taxAuthoritiesCode：主管税务代码 </li> <li> preTaxAmount：不含税价 </li> <li> passengerLimitNumber：限乘人数 </li> <li> issuer：开票人 </li> <li> tonnage：吨位 </li> <li> purchaserTaxNumber：购买方纳税人识别号 </li> <li> taxPaymentNumber：完税凭证号码 </li> </ul>|   
/// |QuotaInvoice| 定额发票 | <ul> <li>invoiceCode：发票代码</li> <li> invoiceNumber：发票号码 </li> <li> AmountInWords：大写金额 </li> <li> Amount：小写金额 </li> <li> title：发票标题 </li> <li> formType：联次 </li> </ul>|
/// |AirItinerary| 航空行程单 | <ul> <li> agentCode：销售单位代号 </li> <li> caacDevelopmentFund：民航发展基金 </li> <li> endorsement：签注 </li> <li> fare：票价 </li> <li> flights：航班详单 </li> <li> fuelSurcharge：燃油附加费 </li> <li> idCardNumber：有效身份证号码 </li> <li> insurance：保险费 </li> <li> internationalFlightSign：国内国际标签 </li> <li> issueCompany：填开单位 </li> <li> issueDate：填开日期 </li> <li> otherTaxes：其他税费 </li> <li> passengerName：旅客姓名 </li> <li> pnrCode：PNR码 </li> <li> promptMessage：提示信息 </li> <li> serialNumber：印刷序号 </li> <li> ticketNumber：电子客票号码 </li> <li> totalAmount：合计 </li> <li> validationCode：验证码 </li> </ul>|
/// |TrainTicket| 火车票 | <ul> <li> departureStation：出发站 </li> <li> arrivalStation：到达站 </li> <li> trainNumber：车次 </li> <li> departureTime：开车时间 </li> <li> seatNumber：座位号 </li> <li> fare：票价 </li> <li> ticketGate：检票口 </li> <li> seatType：座位类型 </li> <li> passengerInfo：旅客信息 </li> <li> passengerName：旅客姓名 </li> <li> ticketNumber：票号 </li> <li> ticketCode：售票码 </li> <li> saleInfo：售票车站信息 </li> </ul>|
/// |TollInvoice| 过路过桥费发票 | <ul> <li> title：标题 </li> <li> formType：联次 </li> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> date：日期 </li> <li> time：时间 </li> <li> vehicleType：车型 </li> <li> entranceName：入口 </li> <li> exitName：出口 </li> <li> totalAmount：总金额 </li> <li> ftype：是否是复印件（1：是，0：否） </li> </ul>|
/// |RollTicket| 增值税发票卷票 | <ul> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> invoiceDate：开票日期 </li> <li> checkCode：校验码 </li> <li> sellerName：销售方名称 </li> <li> sellerTaxNumber：销售方税号 </li> <li> purchaserName：购买方名称 </li> <li> purchaserTaxCode：购买方税号 </li> <li> title：标题 </li> <li> IGNORE：机打号码 </li> <li> machineCode：机器编号 </li> <li> cashier：收款员 </li> <li> totalAmountInWords：合计金额（大写） </li> <li> totalAmount：合计金额（小写） </li> <li> invoiceDetails：发票详单 </li> <li> itemName：项目 </li> <li> quantity：数量 </li> <li> unitPrice：单价 </li> <li> amount：金额 </li> </ul>|
/// |BankAcceptance| 银行承兑汇票 | <ul> <li> issueDate：出票日期 </li> <li> validToDate：到期日期 </li> <li> draftStatus：票据状态 </li> <li> draftNumber：票据号码 </li> <li> issuerName：出票人全称 </li> <li> issuerAccountNumber：出票人账号 </li> <li> issuerAccountBank：出票人开户银行 </li> <li> payeeName：收票人全称 </li> <li> payeeAccountNumber：收票人账号 </li> <li> payeeAccountBank：收票人开户银行 </li> <li> totalAmountInWords：票据金额大写 </li> <li> totalAmount：票据金额小写 </li> <li> acceptorName：承兑人全称 </li> <li> acceptorAccountNumber：承兑人账号 </li> <li> acceptorBankNumber：承兑人开户行行号 </li> <li> acceptorAccountBank：承兑人开户行名称 </li> <li> agreementNumber：交易合同号 </li> <li> assignability：能否转让 </li> <li> acceptanceDate：承兑日期 </li> </ul>|
/// |BusShipTicket| 客运车船票 | <ul> <li> title：标题 </li> <li> formType：发票联次 </li> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> date：日期 </li> <li> time：时间 </li> <li> departureStation：出发车站 </li> <li> arrivalStation：到达车站 </li> <li> totalAmount：总金额 </li> <li> passengerName：姓名 </li> <li> idcardNo：身份证号 </li> </ul>|
/// |NonTaxInvoice| 非税收入发票 | <ul> <li> additionalInfo：其他信息 </li> <li> invoiceCode：票据代码 </li> <li> invoiceDate：开票日期 </li> <li> invoiceDetails：项目详单 </li> <li> invoiceNumber：票据号码 </li> <li> payeeName：收款单位 </li> <li> payerCreditCode：交款人统一社会信用代码 </li> <li> payerName：交款人 </li> <li> recipient：收款人 </li> <li> reviewer：复核人 </li> <li> title：标题 </li> <li> totalAmount：合计金额（小写） </li> <li> totalAmountInWords：合计金额（大写） </li> <li> validationCode：校验码 </li> </ul>|
/// |CommonPrintedInvoice| 通用机打发票 | <ul> <li> title：标题 </li> <li> formType：发票联次 </li> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> printedInvoiceCode：发票代码-机打 </li> <li> printedInvoiceNumber：发票号码-机打 </li> <li> invoiceDate：开票日期 </li> <li> totalAmount：合计金额 </li> <li> sellerName：销售方名称 </li> <li> sellerTaxNumber：销售方纳税人识别号 </li> <li> purchaserName：购买方名称</li> <li> purchaserTaxNumber：购买方纳税人识别号 </li> <li> drawer：开票人</li> <li> recipient：收款人 </li> <li> remarks：备注</li> <li> invoiceDetails：发票详单</li> <li> itemName：项目名称</li> <li> unit：单位</li> <li> quantity：数量</li> <li> unitPrice：单价</li> <li> amount：总值</li> <li> ftype：是否是复印件（1：是，0：否）</li> </ul>|
/// |HotelConsume| 酒店流水 | <ul> <li> fax：传真 </li> <li> phone：电话 </li> <li> postCode：邮编 </li> <li> roomNo：房号 </li> <li> checkInDate：入住日期 </li> <li> departureDate：离店日期 </li> <li> memberNumber：会员号码 </li> <li> totalConsumption：消费总计 </li> <li> name：姓名 </li> <li> roomType：房型 </li> <li> numberOfGuests：住店人数 </li> <li> roomRate：房费 </li> <li> address：地址</li> <li> consumptionDetails：消费详单 </li> <li> _消费详单_ 内字段说明 <ul> <li> date：日期 </li> <li> item：项目 </li> <li> consumption：消费 </li> <li> payment：付款 </li> </ul> </li> </ul>|
/// |PaymentRecord| 支付详情页 | <ul> <li> description：商品说明 </li> <li> orderNumber：订单号 </li> <li> paymentMethod：付款方式 </li> <li> paymentTime：支付时间 </li> <li> recipientName：收款方名称 </li> <li> totalAmount：合计金额 </li> </ul>|
/// |PurchaseRecord| 电商订单页 | <ul> <li> orderNumber：订单编号 </li> <li> transactionTime：交易时间 </li> <li> deliveryInfo：收货信息 </li> <li> totalAmount：交易金额 </li> <li> shopName：店铺名称 </li> <li> ftype：是否是复印件（1：是，0：否）</li> <li> shoppingDetails：商品详单 </li> <li> 商品详单字段说明：<ul> <li> name：商品名称 </li>  <li> specification：商品规格 </li>  <li> price：商品单价 </li>  <li> quantity：商品数量 </li> </ul> </li> </ul>|
/// |RideHailingItinerary| 网约车行程单 | <ul> <li> serviceProvider：服务商 </li> <li> applicationDate：申请日期 </li> <li> startTime：行程开始时间 </li> <li> endTime：行程结束时间 </li> <li> phoneNumber：行程人手机号 </li> <li> totalAmount：总金额 </li> <li> rideDetails：行程详单 </li> <li> Number：序号 </li> <li> carType：车型 </li> <li> pickUpTime：上车时间 </li> <li> city：城市 </li> <li> startPlace：起点 </li> <li> endPlace：终点 </li> <li> mileage：里程 </li> <li> amount：金额 </li> <li> remarks：备注 </li> </ul>|
/// |ShoppingReceipt| 购物小票 | <ul> <li> shopName：开票方名称 </li> <li> receiptDate：开票日期 </li> <li> receiptTime：开票时间 </li> <li> contactNumber：联系电话 </li> <li> shopAddress：地址 </li> <li> totalAmount：合计（实付）金额 </li> <li> receiptDetails：商品详单 </li> </ul>|
/// |TaxClearanceCertificate| 税收完税证明 | <ul> <li> certificateNumber：编号 </li> <li> drawer：填票人 </li> <li> formType：联次 </li> <li> issueDate：填发日期 </li> <li> name：纳税人名称 </li> <li> remarks：备注 </li> <li> taxAuthorityName：税务机关 </li> <li> taxClearanceDetails：完税详单 </li> <li> taxNumbe：纳税人识别号 </li> <li> totalAmount：合计金额（小写） </li> <li> totalAmountInWords：合计金额（大写）</li> </ul>|
/// |UsedCarInvoice| 二手车销售统一发票 | <ul> <li> title：标题 </li> <li> formType：联次 </li> <li> invoiceDate：开票日期 </li> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> printedInvoiceCode：机打代码 </li> <li> printedInvoiceNumber：机打号码 </li> <li> taxCode：税控码 </li> <li> purchaserName：买方单位/个人姓名 </li> <li> purchaserCode：买方单位代码/身份证号码 </li> <li> purchaserAddress：买方单位/个人地址</li> <li> purchaserPhoneNumber：买方电话 </li> <li> sellerName：卖方单位/个人姓名 </li> <li> sellerCode：卖方单位代码/身份证号码 </li> <li> sellerAddress：卖方单位/个人住址 </li> <li> sellerPhoneNumber：卖方电话 </li> <li> licensePlateNumber：车牌照号 </li> <li> certificateNumber：登记证号 </li> <li> vehicleType：车辆类型 </li> <li> vinCode：车架号/车辆识别代码 </li> <li> brandMode：厂牌型号</li> <li> vehicleAdministrationName：转入地车辆管理所名称</li> <li> totalAmountInWords：车价合计（大写） </li>  <li> totalAmount：车价合计（小写）</li> <li> marketName：二手车市场名称 </li> <li> marketTaxNumber：二手车市场纳税人识别号 </li> <li> marketAddress：二手车市场地址 </li> <li> marketBankAccountInfo：二手车市场开户银行及账户 </li> <li> marketPhoneNumber：二手车市场电话 </li> <li> remarks：备注 </li> <li> drawer：开票人 </li> </ul>|
/// |VehicleLicense| 行驶证 | <ul> <li>行驶证正面字段：<ul> <li> address：住址 </li> <li> engineNumber：发动机号码 </li> <li> issueDate：发证日期 </li> <li> model：品牌型号 </li> <li> owner：所有人 </li> <li> licensePlateNumber：号牌号码 </li> <li> registrationDate：注册日期 </li> <li> useNature：使用性质 </li> <li> vehicleType：车辆类型 </li> <li> vinCode：车辆识别代码 </li> <li> issueAuthority：签发机关 </li> </ul> </li>  <li> 行驶证反面字段：<ul> <li> licensePlateNumber：号牌号码 </li> <li> inspectionRecord：检验记录 </li> <li> passengerCapacity：核定载人数 </li> <li> totalWeight：总质量 </li> <li> curbWeight：整备质量 </li> <li> permittedWeight：和钉载质量 </li> <li> overallDimension：外廓尺寸 </li> <li> tractionWeight：准牵引总质量 </li> <li> energySign：能源标志 </li> <li> recordNumber：档案编号 </li> <li> remarks：备注 </li> </ul> </li> </ul>|
/// |DrivingLicense| 驾驶证 | <ul> <li>驾驶证正面字段：<ul> <li> licenseNumber：证号 </li> <li> name：姓名 </li> <li> sex：性别 </li> <li> nationality：国籍 </li> <li> address：住址 </li> <li> birthDate：出生日期 </li> <li> initialIssueDate：初次领证日期 </li> <li> approvedType：准驾类型 </li> <li> issueAuthority：发证单位 </li> <li> validFromDate：有效起始日期 </li> <li> validPeriod：有效期限 </li> </ul> </li>  <li> 驾驶证反面字段：<ul> <li> name：姓名 </li> <li> recordNumber：档案编号 </li> <li> record：记录 </li> <li> licenseNumber：证号 </li> </ul> </li> </ul>|
/// |VehicleRegistration| 机动车登记证 | <ul> <li> acquisitionMethod：车辆获得方式 </li> <li> axleNumber：轴数 </li> <li> barCode：条形编号 </li> <li> cabPassengerCapacity：驾驶室载客 </li> <li> containerDimension：货箱内部尺寸 </li> <li> displacement：排量 </li> <li> engineNumber：发动机号 </li> <li> engineType：发动机型号 </li> <li> frontWheelTrack：轮距前 </li> <li> fuelType：燃料种类 </li> <li> isDomestic：国产/进口 </li> <li> issueAuthority：发证机关 </li> <li> issueDate：发证日期 </li> <li> manufactureDate：车辆出厂日期 </li> <li> manufactureName：制造厂名称 </li> <li> overallDimension：外轮廓尺寸 </li> <li> passengerCapacity：驾驶室载客 </li> <li> permittedWeight：核定载质量 </li> <li> power：功率 </li> <li> rearWheelTrack：轮距后 </li> <li> registrationAuthority：登记机关 </li> <li> registrationDate：登记日期 </li> <li> registrationNumber：机动车登记编号 </li> <li> springNumber：钢板弹簧数 </li> <li> steeringForm：转向形式 </li> <li> tireNumber：轮胎数 </li> <li> tireSize：轮胎规格 </li> <li> totalWeight：总质量 </li> <li> tractionWeight：准牵引总质量 </li> <li> useNature：使用性质 </li> <li> vehicleBrand：车辆品牌 </li> <li> vehicleColor：车身颜色 </li> <li> vehicleModel：车辆型号 </li> <li> vehicleOwnerInfo：机动车所有人/身份证明名称/号码 </li> <li> vehicleType：车辆类型 </li> <li> vinCode：车辆识别代号/车架号 </li> <li> wheelbase：轴距 </li> </ul> |
/// |VehicleCertification| 车辆合格证 | <ul> <li> MaximumLoadMass：半挂车鞍座最大允许总质量 </li> <li> axleLoad：轴荷 </li> <li> axleNumber：轴数 </li> <li> cabPassengerCapacity：驾驶室准驾人数 </li> <li> certificateNumber：合格证编号 </li> <li> chassisCertificateNumber：底盘合格证编号 </li> <li> chassisId：底盘ID </li> <li> chassisModel：底盘型号 </li> <li> containerDimension：货箱内部尺寸 </li> <li> displacement：排量 </li> <li> emissionStandard：排放标准 </li> <li> engineModel：发动机型号 </li> <li> engineNumber：发动机号 </li> <li> equipmentWeight：装备质量 </li> <li> frontWheelTrack：轮距前 </li> <li> fuelConsumption：油耗 </li> <li> fuelType：燃料种类 </li> <li> issueDate：发证日期 </li> <li> manufactureDate：车辆制造日期 </li> <li> manufactureName：车辆制造企业名称 </li> <li> massUtilizationCoefficient：载质量利用系数 </li> <li> maxDesignSpeed：最高设计车速 </li> <li> maximumLadenMass：额定载质量 </li> <li> overallDimension：外廓尺寸 </li> <li> passengerCapacity：额定载客 </li> <li> power：功率 </li> <li> rearWheelTrack：轮距后 </li> <li> remarks：备注 </li> <li> springNumber：钢板弹簧数 </li> <li> steeringForm：转向形式 </li> <li> tireNumber：轮胎数 </li> <li> tireSize：轮胎规格 </li> <li> totalWeight：总质量 </li> <li> tractionWeight：准牵引总质量 </li> <li> vehicleBrand：车辆品牌 </li> <li> vehicleColor：车身颜色 </li> <li> vehicleModel：车辆型号 </li> <li> vehicleName：车辆名称 </li> <li> vinCode：车辆识别代号/车架号 </li> <li> wheelbase：轴距 </li> </ul> |
/// |LicensePlateNumber| 车牌 | <ul> <li> data：车牌信息 </li> </ul> |
/// |CarVinCode| 车辆vin码 | <ul> <li> vinCode：车牌vin码信息 </li> </ul>|
/// |BusinessLicense| 营业执照 | <ul><li> title：标题 </li>  <li> creditCode：统一社会信用代码 </li> <li> companyName：营业名称 </li> <li> companyType：类型 </li> <li> businessAddress：营业场所/住所 </li> <li> legalPerson：法人/负责人 </li> <li> businessScope：经营范围 </li> <li> registeredCapital：注册资本 </li> <li> RegistrationDate：注册日期 </li> <li> issueDate：发证日期 </li> <li> validPeriod：营业期限 </li> <li> validFromDate：格式化营业期限起始日期 </li> <li> validToDate：格式化营业期限终止日期 </li> <li> companyForm：组成形式 </li> </ul> |
/// |BusinessLicense| 国际企业执照 | <ul> <li>印度公司注册证字段：<ul><li>certificateType：证件类型</li><li>registrationNo：注册号</li><li>legalName：法定名称</li><li>tradeName：商号</li><li>businessConstitution：商业类型</li><li>businessAddress：地址</li><li>liabilityDate：责任日期</li><li>validFromDate：有效起始日期</li><li>validToDate：有效终止日期</li><li>registrationType：注册类型</li><li>particularsOfApprovingAuthority：审批机关详情</li><li>name：姓名</li><li>designation：委任</li><li>jurisdictionalOffice：管辖办事处</li><li>issueDate：签发日期</li></ul></li> <li>韩国商业登记证字段：<ul><li>certificateType：证件类型</li><li>issuanceNo：发行号</li><li>processingTime：处理时间</li><li>companyNameEn：英文公司名称</li><li>companyName：非英文公司名称</li><li>registrationNo：商业注册号</li><li>nameOfRepresentativeEn：英文法人姓名</li><li>nameOfRepresentative：非英文法人姓名</li><li>residentRegistrationNo：法人证件号</li><li>businessAddressEn：英文商业地址</li><li>businessAddress：非英文商业地址</li><li>businessCommencementDate：商业起始时间</li><li>businessRegistrationDate：商业注册时间</li><li>businessTypeEn：英文商业类型</li><li>businessType：非英文商业类型</li><li>businessItemEn：英文经营范围</li><li>businessItem：非英文经营范围</li><li>jointCompanyName：联合企业名称</li><li>jointCompanyRegistrationNo：联合企业注册号</li><li>issueDate：签发日期</li><li>issuer：签发人</li></ul> </li> </ul> |
/// |MedicalDeviceManageLicense| 医疗器械经营许可证 | <ul><li>title：证照标题</li><li>licenseNumber：许可证编号</li><li>companyName：企业名称</li><li>businessType：经营方式</li><li>officeAddress：住所</li><li>businessScope：经营范围</li><li>businessAddress：经营场所</li><li>warehouseAddress：库房/仓库地址</li><li>issueDate：发证日期</li><li>issueAuthority：发证部门</li><li>legalRepresentative：法定代表人</li><li>responsiblePerson：企业负责人</li><li>qualityManager：质量管理人</li><li>registeredAddress：注册地址</li><li>validToDate：有效期限/许可期限</li></ul> |
/// |MedicalDeviceProduceLicense| 医疗器械生产许可证 | <ul><li>registeredAddress：注册地址</li><li>issueDate：发证日期</li><li>licenseNumber：许可证编号</li><li>issueAuthority：发证部门</li><li>legalRepresentative：法定代表人</li><li>productionAddress：生产地址</li><li>responsiblePerson：企业负责人</li><li>companyName：企业名称</li><li>validToDate：有效期限</li><li>officeAddress：住所</li><li>productionScope：生产范围</li></ul> |
/// |CosmeticProduceLicense| 化妆品生产许可证 | <ul><li>title：证照名称</li><li>enterpriseName：企业名称</li><li>creditCode：社会信用代码</li><li>officeAddress：住址</li><li>legalRepresentative：法定代表人</li><li>responsiblePerson：企业负责人</li><li>safetyManager：质量安全负责人</li><li>productionAddress：生产地址</li><li>licenceNumber：许可证编号</li><li>licensedItemScope：许可项目</li><li>regulatoryAuthority：日常监督管理机关</li><li>regulatoryPersonnel：日常监督管理人员</li><li>reportHotline：投诉举报电话</li><li>issueOfficer：签发人</li><li>issueAuthority：发证机关</li><li>issueDate：发证日期</li><li>validToDate：有效期至</li><li>ftype：是否是复印件</li></ul> |
/// |TaxiInvoice| 出租车发票 | <ul> <li> date：乘车日期 </li> <li> dropOffTime：下车时间 </li> <li> fare：金额 </li> <li> invoiceCode：发票代码 </li> <li> invoiceNumber：发票号码 </li> <li> licensePlateNumber：车牌号 </li> <li> mileage：里程 </li> <li> pickUpTime：上车时间 </li> </ul> |
/// |TrademarkCertificate| 商标注册证 | <ul><li>validToDate：有效期至</li><li>registeredAddress：注册人地址</li><li>registrationDate：注册日期</li><li>registrant：注册人</li><li>approvedRightScope：核定使用商品/服务项目</li><li>iprNumber：知识产权编号</li><li>certificateNumber：编码</li></ul> |
/// |FoodProduceLicense| 食品生产许可证 | <ul> <li> producerName：生产者名称 </li> <li> creditCode：社会信用代码（身份证号码） </li> <li> legalRepresentative：法定代表人（负责人） </li> <li> officeAddress：住所 </li> <li> productionAddress：生产地址 </li> <li> foodType：食品类别 </li> <li> licenceNumber：许可证编号 </li> <li> regulatoryAuthority：日常监督管理机构 </li> <li> regulatoryPersonnel：日常监督管理人员 </li> <li> reportHotline：投诉举报电话 </li> <li> issueAuthority：发证机关 </li> <li> issueOfficer：签发人 </li> <li> issueDate：签发日期 </li> <li> validToDate：有效期至 </li> </ul> |
/// |FoodManagementLicense| 食品经营许可证 | <ul> <li> operatorName：经营者名称 </li> <li> creditCode：社会信用代码（身份证号码） </li> <li> legalRepresentative：法定代表人（负责人） </li> <li> officeAddress：住所 </li> <li> businessAddress：经营场所 </li> <li> mainBusiness：主体业态 </li> <li> businessScope：经营项目 </li> <li> licenceNumber：许可证编号 </li> <li> regulatoryAuthority：日常监督管理机构 </li> <li> regulatoryPersonnel：日常监督管理人员 </li> <li> reportHotline：投诉举报电话 </li> <li> issueAuthority：发证机关 </li> <li> issueOfficer：签发人 </li> <li> issueDate：签发日期 </li> <li> standardizedIssueDate：格式化签发日期 </li> <li> validToDate：有效期至 </li> <li> standardizedValidToDate：格式化有效期至 </li> </ul> |
/// |ClassIIMedicalDeviceManageLicense| 第二类医疗器械经营备案凭证 | <ul> <li> recordNumber：备案编号 </li> <li> companyName：企业名称 </li> <li> officeAddress：住所 </li> <li> businessAddress：经营场所 </li> <li> warehouseAddress：库房地址 </li> <li> businessType：经营方式 </li> <li> legalRepresentative：法定代表人 </li> <li> responsiblePerson：企业负责人 </li> <li> businessScope：经营范围 </li> <li> recordationAuthority：备案部门 </li> <li> recordationDate：备案日期 </li> </ul> |
/// |WayBill| 电子面单 | <ul> <li> recipientName：收件人姓名 </li> <li> senderAddress：寄件人姓名 </li> <li> senderPhoneNumber：寄件人电话 </li> <li> senderAddress：寄件人地址 </li> <li> recipientPhoneNumber：收件人电话 </li> <li> recipientAddress：收件人地址 </li> </ul> |
/// |BankAccountPermit| 银行开户许可证 | <ul> <li> bankAccount：账号 </li> <li> legalRepresentative：法定代表人 </li> <li> depositaryBank：开户银行 </li> <li> approvalNumber：核准号 </li> <li> customerName：名称 </li> <li> permitNumber：编号 </li> <li> title：标题 </li> </ul> |
///
/// Return value of [Connection::recognize_all_text()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeAllTextResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID。
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 识别结果。
    #[serde(rename = "Data")]
    pub data: Option<TextResponseData>,
}
/// #### 如何使用本接口
///
/// | 步骤 | 概述                                                                                                                                                                                                                                                                                                                                                                                                                                      |
/// | ---- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
/// | 1    | 开通 [OCR 统一识别](https://common-buy.aliyun.com/?commodityCode=ocr_unity_public_cn) 服务。本接口在公测阶段，是免费接口，开通后即可调用。
/// | 3    | 可以参照[调试页面](https://api.aliyun.com/api/ocr-api/2021-07-07/RecognizeGeneralStructure?sdkStyle=dara) 提供的代码示例完成 API 接入开发。接入完成后，调用 API 获取识别结果。如果使用子账号调用接口，需要阿里云账号（主账号）对 RAM 账号进行授权。创建 RAM 用户的具体操作，请参考：[创建 RAM 用户。](https://help.aliyun.com/document_detail/93720.html)文字识别服务提供一种系统授权策略，即**AliyunOCRFullAccess**。具体授权操作，请参见[在用户页面为 RAM 用户授权。](https://help.aliyun.com/document_detail/116146.html) |
///
/// #### 重要提示
///
/// | 类型     | 概述                                                                                                                                                                      |
/// | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
/// | 图片格式 | <ul> <li>本接口支持：PNG、JPG、JPEG、PDF、BMP、GIF、TIFF、WebP。</li></ul>                                        |
/// | 图片尺寸 | <ul> <li> 图片长宽需要大于 15 像素，小于 8192 像素。</li> <li>长宽比需要小于 50。</li> <li>如需达到较好识别效果，建议长宽均大于 500px。</li> </ul>                        |
/// | 图片大小 | <ul> <li> 图片二进制文件不能超过 10MB。</li> <li> 图片过大会影响接口响应速度，建议使用小于 1.5M 图片进行识别，且通过传图片 URL 的方式调用接口。</li> </ul>                |
/// | 其他提示 | <ul> <li>请保证整张图片内容及其边缘包含在图像内。 </li> <li> 本能力会自动处理反光、扭曲等干扰信息，但会影响精度。请尽量选择清晰度高、无反光、无扭曲的图片。 </li><li> PDF类型文件仅识别第一页。 </li> </ul> |
/// ---
///
/// Return value of [Connection::recognize_general_structure()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeGeneralStructureResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID。
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 识别结果。
    #[serde(rename = "Data")]
    pub data: Option<StructureResponseData>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|图片的角度（当NeedRotate=true时，返回此字段）。0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |content|string|识别出图片的文字块汇总。|
/// |figure|list|图片中的图案信息（当OutputFigure=true时，返回此字段）。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_tablesInfo|list|表格信息（当OutputTable=true时，返回此字段）。|
/// |prism_paragraphsInfo|list|段落信息（当Paragraph=true时，返回此字段）。|
/// |prism_rowsInfo|list|行信息（当Row=true时，返回此字段）。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。当NeedRotate=true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确。|
/// |word|string|文字块的文字内容。|
/// |tableId|int|表格的id（当OutputTable=true时，返回此字段）。|
/// |tableCellId|int|表格中单元格的id（当OutputTable=true时，返回此字段）。|
/// |charInfo|list|单字信息。|
///
/// #### 单字信息（charInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |word|string|单字文字。|
/// |prob|int|置信度。|
/// |x|int|单字左上角横坐标。|
/// |y|int|单字左上角纵坐标。|
/// |w|int|单字宽度。|
/// |h|int|单字高度。|
///
/// #### 表格信息（prism_tablesInfo字段。当OutputTable=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableId|int|表格id，和prism_wordsInfo信息中的tableId对应。|
/// |xCellSize|int|表格中横坐标单元格的数量。|
/// |yCellSize|int|表格中纵坐标单元格的数量。|
/// |cellInfos|list|单元格信息。|
///
/// #### 单元格信息（cellInfos字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableCellId|int|表格中单元格id，和prism_wordsInfo信息中的tableCellId对应。|
/// |word|string|单元格中的文字。|
/// |xsc|int|xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |xec|int|xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内。|
/// |ysc|int|yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |yec|int|yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0。|
/// |pos|list|单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标。|
///
/// #### 段落信息（prism_paragraphsInfo字段。当Paragraph=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |paragraphId|int|段落id，和prism_wordsInfo信息中的paragraphId对应。|
/// |word|string|段落文字。|
///
/// #### 行信息（prism_rowsInfo字段。当Row=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |rowId|int|行id，和prism_wordsInfo信息中的rowId对应。|
/// |word|string|行文字。|
///
/// #### 图案位置信息（figure字段。当OutputFigure=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|图案类型。blicense_title营业执照标题，national_emblem中国国徽，barcode条形码，qrcode二维码，face人脸，finger_print指纹，signature签名，round_stamp圆形印章，oval_stamp椭圆印章，rectangular_stamp矩形印章，square_stamp方形印章，rhombus_stamp菱形印章|
/// |x|int|图案左上角横坐标。|
/// |y|int|图案左上角纵坐标。|
/// |w|int|图案宽度。|
/// |h|int|图案高度。|
/// |box|object|图案坐标信息：中心横纵坐标，长宽，顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|图案四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_advanced()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeAdvancedResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|图片的角度（当NeedRotate=true时，返回此字段）。0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |content|string|识别出图片的文字块汇总。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_paragraphsInfo|list|段落信息（当Paragraph=true时，返回此字段）。|
/// |prism_tablesInfo|list|表格信息（当OutputTable=true时，返回此字段）。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。当NeedRotate=true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确。|
/// |word|string|文字块的文字内容。|
/// |tableId|int|表格的id（当OutputTable=true时，返回此字段）。|
/// |tableCellId|int|表格中单元格的id（当OutputTable=true时，返回此字段）。|
/// |charInfo|list|单字信息。|
///
/// #### 单字信息（charInfo字段。当OutputCharInfo=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |word|string|单字文字。|
/// |prob|int|置信度。|
/// |x|int|单字左上角横坐标。|
/// |y|int|单字左上角纵坐标。|
/// |w|int|单字宽度。|
/// |h|int|单字高度。|
///
/// #### 表格信息（prism_tablesInfo字段。当OutputTable=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableId|int|表格id，和prism_wordsInfo信息中的tableId对应。|
/// |xCellSize|int|表格中横坐标单元格的数量。|
/// |yCellSize|int|表格中纵坐标单元格的数量。|
/// |cellInfos|list|单元格信息。|
///
/// #### 单元格信息（cellInfos字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableCellId|int|表格中单元格id，和prism_wordsInfo信息中的tableCellId对应。|
/// |word|string|单元格中的文字。|
/// |xsc|int|xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |xec|int|xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内。|
/// |ysc|int|yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |yec|int|yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0。|
/// |pos|list|单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标。|
///
/// #### 段落信息（prism_paragraphsInfo字段。当Paragraph=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |paragraphId|int|段落id，和prism_wordsInfo信息中的paragraphId对应。|
/// |word|string|段落文字。|
///
/// Return value of [Connection::recognize_handwriting()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeHandwritingResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|图片的角度（当NeedRotate=true时，返回此字段）。0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |content|string|识别出图片的文字块汇总。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。如果最外层的 angle 不为 0，需要按照 angle 矫正图片后，坐标才准确。|
/// |word|string|文字块的文字内容。|
///
/// Return value of [Connection::recognize_basic()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeBasicResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |content|string|识别出图片的文字块汇总。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。|
/// |word|string|文字块的文字内容。|
///
/// Return value of [Connection::recognize_general()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeGeneralResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|图片的角度。0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |content|string|识别出图片的文字块汇总。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_tablesInfo|list|表格信息。|
/// |tableHeadTail|list|表头、表尾信息。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。当NeedRotate=true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确。|
/// |word|string|文字块的文字内容。|
/// |tableId|int|表格的id（当OutputTable=true时并且该文字块在表格内则存在该字段，返回此字段）。|
/// |tableCellId|int|表格中单元格的id（当OutputTable=true时并且该文字块在表格内则存在该字段，返回此字段）。|
///
///
/// #### 表格信息（prism_tablesInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableId|int|表格id，和prism_wordsInfo信息中的tableId对应。|
/// |xCellSize|int|表格中横坐标单元格的数量。|
/// |yCellSize|int|表格中纵坐标单元格的数量。|
/// |cellInfos|list|单元格信息。|
///
///
/// #### 单元格信息（cellInfos字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableCellId|int|表格中单元格id，和prism_wordsInfo信息中的tableCellId对应。|
/// |word|string|单元格中的文字。|
/// |xsc|int|xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |xec|int|xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内。|
/// |ysc|int|yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |yec|int|yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0。|
/// |pos|list|单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标。|
///
/// #### 表头、表尾信息（tableHeadTail字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |head|list|表头信息。|
/// |tableId|int|表格ID（和**prism_tablesInfo**中的**tableId**对应）。|
/// |tail|list|表尾信息。|
///
/// Return value of [Connection::recognize_table_ocr()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeTableOcrResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息，正面为face字段，反面为back字段。|
/// |sliceRect|list|结构化信息的坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |name|string|姓名。|
/// |idNumber|string|证件号码。|
/// |date|string|日期。|
/// |time|string|时间。|
/// |color|string|颜色。|
/// |remarks|string|备注信息。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_health_code()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeHealthCodeResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// ## 返回字段补充说明
/// ```ignore
/// 第一种返回格式（UseNewStyleOutput=false）
/// angle    图片的角度，当NeedRotate为true时才会返回，0表示正向，90表示图片朝右，180朝下，270朝左
/// content    识别出图片的文字块汇总
/// height    算法矫正图片后的高度
/// width    算法矫正图片后的宽度
/// orgHeight    原图的高度
/// orgWidth    原图的宽度
/// prism_wnum    识别的文字块的数量，prism_wordsInfo数组的大小
/// --------------------------prism-wordsInfo文字块数组内的字段说明--------------------------
/// angle    文字块的角度，这个角度只影响width和height，当角度为-90、90、-270、270，width和height的值需要自行互换
/// height    文字块的高度
/// width    文字块的宽度
/// pos    文字块的外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下
/// word    文字块内容
/// tableId    当OutputTable为true并且该文字块在表格内则存在该字段，tableId表示表格的id
/// tableCellId    当OutputTable为true并且该文字块在表格内则存在该字段，表示表格中单元格的id
/// paragraphId    当Paragraph为true返回该字段，表示段落id
/// -----------------------------------------charInfo单字信息-------------------------------------------
/// word    单字文字
/// prob    置信度
/// x    单字左上角横坐标
/// y    单字左上角纵坐标
/// w    单字宽度
/// h    单字高度
/// -----------------------------------------------------------------------------------------------------------
/// -----------------------------------------------------------------------------------------------------------
/// ----------------------------prism-tablesInfo表格数组内的字段说明---------------------------
/// tableId    表格id，和prism_wordsInfo信息中的tableId对应
/// xCellSize    表格中横坐标单元格的数量
/// yCellSize    表格中纵坐标单元格的数量
/// -------------cellInfos单元格信息，包含单元格在整个表格中的空间拓扑关系-----------
/// tableCellId    表格中单元格id，和prism_wordsInfo信息中的tableCellId对应
/// word    单元格中的文字
/// xsc    xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0
/// xec    xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内
/// ysc    yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0
/// yec    yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0
/// pos    单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标
///
/// ------------------------------------------------------------------------------------
/// 第二种返回格式（UseNewStyleOutput=true）
/// docInfo    文档信息
/// layouts    版面信息列表
/// version    doc-json版本信息
/// ----------------------------------------docInfo中的字段----------------------------------------
/// pages    文档页面列表
/// imageWidth    页面转图后的宽
/// imageHeight    页面转图后的高
/// pageIdAllDocs    页面在所有文档的页索引
/// pageIdCurDoc    页面在当前文档的页索引
/// ----------------------------------------layouts中的字段----------------------------------------
/// alignment    间距枚举（LEFT、CENTER、RIGHT、BOTH）
/// blocks    字块信息列表
/// text    文本内容
/// firstLinesChars    文字首行缩进
/// index    版面阅读顺序
/// lineHeight    行平均高度
/// pageNum    单元格所在页数
/// pos    文字块的外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下
/// type    版面类型（title：标题、table：表格、table_name：表格名、table_note：表注、multicolumn：多栏文字、formula：公式、contents_title：目录标题、contents：目录主体、text：普通文字、figure：图表、foot：页脚、head：页眉、side：侧栏）
/// uniqueId    版面信息唯一id
/// numCol    表格总列数
/// numRow    表格总行数
/// cells    单元格信息
/// ```
///
/// Return value of [Connection::recognize_document_structure()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeDocumentStructureResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息，正面为face字段，反面为back字段。|
/// |figure|list|身份证人像面的人脸位置信息（当OutputFigure=true时，返回此字段）。|
/// |sliceRect|object|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |warning|object|身份证质量检测信息（当OutputQualityInfo=true时，返回此字段）。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 正面识别结果（face字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |name|string|姓名。|
/// |sex|string|性别。|
/// |ethnicity|string|民族。|
/// |birthDate|string|出生日期。|
/// |address|string|住址。|
/// |idNumber|string|身份证号码。|
///
/// #### 反面识别结果（back字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |issueAuthority|string|签发机关。|
/// |validPeriod|string|有效期限。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 正面人像位置信息（figure字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|图案类型。|
/// |x|int|人像图案左上角横坐标。|
/// |y|int|人像图案左上角纵坐标。|
/// |w|int|人像图案宽度。|
/// |h|int|人像图案高度。|
/// |box|object|人像图案坐标信息：人像图案中心横纵坐标，长宽，图案顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|人像图案四个点坐标（左上、右上、右下、左下）。|
///
/// #### 身份证质量检测识别结果（warning字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |isCopy|int|是否是复印件（1：是，0：否）。|
/// |isReshoot|int|是否是翻拍（1：是，0：否）。|
/// |completenessScore|float|完整度评分。|
/// |qualityScore|float|整体质量分数。|
/// |tamperScore|float|篡改指数（数值越大表示篡改可能性越大，推荐阈值：60）。|
///
/// Return value of [Connection::recognize_idcard()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeIdcardResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |passportType|string|证件类型。|
/// |surname|string|姓。|
/// |givenName|string|名。|
/// |passportNumber|string|护照号码。|
/// |nationality|string|国家码。|
/// |nameEn|string|英文姓名。|
/// |name|string|非英文姓名。|
/// |sex|string|性别。|
/// |birthPlaceEn|string|出生地。|
/// |birthPlace|string|非英文出生地。|
/// |country|string|国籍。|
/// |validToDate|string|有效期至。|
/// |birthDate|string|出生日期。|
/// |birthDateYmd|string|出生日期-年月日。|
/// |issueDateYmd|string|签发日期。|
/// |issuePlaceEn|string|签发地。|
/// |issuePlace|string|非英文签发地。|
/// |issueAuthorityEn|string|签发机关。|
/// |issueAuthority|string|非英文签发机关。|
/// |idNumber|string|身份号。|
/// |mrzLine1|string|机读码一。|
/// |mrzLine2|string|机读码二。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_passport()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizePassportResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（户主页***data***字段，当**IsResidentPage**不传或传false。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |Registrar|string|承办人签章。|
/// |address|string|住址。|
/// |householdNumber|string|户号。|
/// |householdType|string|户别。|
/// |householderCommunity|string|户主社区。|
/// |householderName|string|户主姓名。|
/// |issueDate|string|签发日期。|
/// |sectionNo|string|地段号。|
///
/// #### 结构化信息（常住人口页***data***字段，当**IsResidentPage=true**。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |birthDate|string|出生日期。|
/// |birthPlace|string|出生地。|
/// |bloodGroup|string|血型。|
/// |educationalDegree|string|文化程度。|
/// |employer|string|服务处所。|
/// |ethnicity|string|民族。|
/// |formerName|string|曾用名。|
/// |householdNumber|string|户号。|
/// |idCardNumber|string|身份证编号。|
/// |immigratedToCityInfo|string|何时何地迁来本市。|
/// |immigratedToResidenceInfo|string|何时由何地迁来本址。|
/// |maritalStatus|string|婚姻状况。|
/// |militaryServiceStatus|string|兵役状况。|
/// |name|string|姓名。|
/// |nativePlace|string|籍贯。|
/// |occupation|string|职业。|
/// |otherResidence|string|本市其他住址。|
/// |registrar|string|承办人签章。|
/// |registrationDate|string|登记日期。|
/// |relation|string|与户主关系。|
/// |religious|string|宗教信仰。|
/// |sex|string|性别。|
/// |stature|string|身高。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_household()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeHouseholdResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |figure|list|图片中的图案信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 识别结果（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |area|string|面积。|
/// |certificateNumber|string|证号。|
/// |mutualOwnershipState|string|共有情况。|
/// |obligee|string|权利人。|
/// |location|string|坐落地址。|
/// |unitNumber|string|不动产单元号。|
/// |rightType|string|权利类型。|
/// |rightProperty|string|权利性质。|
/// |usage|string|用途。|
/// |serviceLife|string|使用期限。|
/// |otherState|string|权利其他状况。|
/// |buildingArea|string|房屋建筑面积。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_estate_certification()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEstateCertificationResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |cardType|string|卡种（CC（贷记卡），SCC（准贷记卡），DCC（存贷合一卡），DC（储蓄卡），PC（预付卡））。|
/// |bankName|string|银行名称。|
/// |cardNumber|string|银行卡号。|
/// |validToDate|string|有效期限。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_bank_card()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeBankCardResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |neonatalName|string|新生儿姓名。|
/// |sex|string|性别。|
/// |birthTime|string|出生时间。|
/// |gestationalAge|string|出生孕周。|
/// |birthWeight|string|出生体重。|
/// |birthLength|string|出生身长。|
/// |birthPlace|string|出生地。|
/// |medicalInstitutions|string|医疗机构名称。|
/// |motherName|string|母亲姓名。|
/// |motherAge|string|母亲年龄。|
/// |motherNationality|string|母亲国籍。|
/// |motherEthnicity|string|母亲民族。|
/// |motherAddress|string|母亲住址。|
/// |motherIdCardNumber|string|母亲有效身份证件号。|
/// |fatherName|string|父亲姓名。|
/// |fatherAge|string|父亲年龄。|
/// |fatherNationality|string|父亲国籍。|
/// |fatherEthnicity|string|父亲民族。|
/// |fatherAddress|string|父亲住址。|
/// |fatherIdCardNumber|string|父亲有效身份证件号。|
/// |issueAuthority|string|签发机构。|
/// |issueDate|string|签发日期。|
/// |certificateNumber|string|编号。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_birth_certification()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeBirthCertificationResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
/// passportType 证件类型
/// countryCode  国家码
/// passportNumber  护照号码
/// nameEn  英文姓名
/// name  中文姓名
/// sex  性别
/// birthPlace  出生地
/// nationality  国籍
/// issuePlace 签发地
/// issueAuthority 签发机关
/// mrzLine1  机读码一
/// mrzLine2 机读码二
/// validToDate  有效期至
/// birthDate  出生日期
/// issueDate  签发日期
/// height            算法矫正图片后的高度
/// width             算法矫正图片后的宽度
/// orgHeight      原图的高度
/// orgWidth       原图的宽度
/// ----------------------------------------prism_keyValueInfo文字块数组内的字段说明---------------------------------------
/// valuePos 外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下
/// ```
///
/// Return value of [Connection::recognize_chinese_passport()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeChinesePassportResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |birthDate|string|出生日期。|
/// |issueAuthority|string|签发机关。|
/// |issueCount|string|签发次数。|
/// |issuePlace|string|签发地点。|
/// |nameCn|string|中文姓名。|
/// |nameEn|string|英文姓名。|
/// |permitNumber|string|证件号码。|
/// |permitType|string|证件类别。|
/// |sex|string|性别。|
/// |validPeriod|string|有效期限。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_exit_entry_permit_to_mainland()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeExitEntryPermitToMainlandResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
/// permitType  证件类别
/// nameCn 中文姓名
/// nameEn 英文姓名
/// birthDate 出生日期
/// sex 性别
/// validPeriod 有效期限
/// issueAuthority 签发机关
/// issuePlace 签发地
/// permitNumber 证件号码
/// mrzCode 机读码
/// angle              角度：0-360，0表示向上，90表示向右，180表示向下，270度表示向左
/// height            算法矫正图片后的高度
/// width             算法矫正图片后的宽度
/// orgHeight      原图的高度
/// orgWidth       原图的宽度
/// ----------------------------------------prism_keyValueInfo文字块数组内的字段说明---------------------------------------
/// valuePos 外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下
/// ```
///
/// Return value of [Connection::recognize_exit_entry_permit_to_hk()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeExitEntryPermitToHKResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |figure|list|身份证人像面的人脸位置信息。|
/// |sliceRect|list|结构化信息的坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |birthDate|string|出生日期。|
/// |firstIssuedDate|string|首次签发日期。|
/// |idNumber|string|身份证号码。|
/// |issuedCode|string|签发标志。|
/// |issuedDate|string|签发日期。|
/// |nameCn|string|中文姓名。|
/// |nameCode|string|姓名电码。|
/// |nameEn|string|英文姓名。|
/// |sex|string|性别。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 正面人像位置信息（figure字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|图案类型。|
/// |x|int|人像图案左上角横坐标。|
/// |y|int|人像图案左上角纵坐标。|
/// |w|int|人像图案宽度。|
/// |h|int|人像图案高度。|
/// |box|object|人像图案坐标信息：人像图案中心横纵坐标，长宽，图案顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|人像图案四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_hk_idcard()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeHKIdcardResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
/// |sliceRect|list|检测出的子图坐标信息。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |bankAccount|string|银行账号。|
/// |cardNumber|string|社保保障卡号。|
/// |idNumber|string|社会保障号码。|
/// |issueDate|string|发卡日期。|
/// |name|string|姓名。|
/// |title|string|标题。|
/// |validPeriod|string|有效期限。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_social_security_card_version_ii()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeSocialSecurityCardVersionIIResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息，正面为face字段，反面为back字段。|
/// |sliceRect|list|结构化信息的坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 印度身份证正面识别结果（face字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |name|string|本国姓名。|
/// |nameEn|string|英文姓名。|
/// |birthDate|string|出生日期。|
/// |sex|string|性别。|
/// |cardNumber|string|证件号码。|
/// |virtualNumber|string|虚拟号码。|
///
/// #### 印度身份证反面识别结果（back字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |address|string|本国地址。|
/// |addressEn|string|英文地址。|
/// |cardNumber|string|证件号码。|
/// |virtualNumber|string|虚拟号码。|
///
/// #### 印度纳税人识别证识别结果
/// |字段|类型|说明|
/// |-----|---|--|
/// |birthDate|string|生日。|
/// |fatherName|string|父亲姓名。|
/// |name|string|姓名。|
/// |taxId|string|税号。|
///
///
/// #### 越南身份证正面识别结果（face字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |birthDate|string|出生日期。|
/// |validToDate|string|有效期至。|
/// |residence|string|居住地。|
/// |cardType|string|证件类型。|
/// |placeOfAncestry|string|原籍地。|
/// |cardNumber|string|证件号码。|
/// |name|string|姓名。|
/// |sex|string|性别。|
/// |nationality|string|国籍。|
///
///
/// #### 越南身份证反面识别结果（back字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |issuer|string|签发人。|
/// |mrzLine1|string|机读码一。|
/// |mrzLine2|string|机读码二。|
/// |mrzLine3|string|机读码三。|
/// |personalCharacteristics|string|身份识别特征。|
/// |issueDate|string|签发日期。|
///
///
/// #### 韩国身份证识别结果
/// |字段|类型|说明|
/// |-----|---|--|
/// |name|string|本国姓名。|
/// |nameChn|string|中文姓名。|
/// |cardNumber|string|证件号码。|
/// |address|string|住址。|
/// |issueDate|string|签发日期。|
/// |issuer|string|签发人。|
///
/// #### 孟加拉国身份证识别结果
/// |字段|类型|说明|
/// |-----|---|--|
/// |name|string|本国姓名。|
/// |nameEn|string|英文姓名。|
/// |fatherName|string|父亲姓名。|
/// |motherName|string|母亲姓名。|
/// |birthDate|string|出生日期。|
/// |cardNumber|string|身份证号。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_international_idcard()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeInternationalIdcardResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 调用成功时，返回的设备事件记录。
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
/// |count|int|识别的图片个数。|
/// |subMsgs|list|图片信息。|
///
/// #### 发票信息（subMsgs字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |result|object|结构化信息。|
/// |op|String|图片类型-英文。|
/// |sliceRect|object|检测出的子图坐标信息。|
/// |index|int|图片顺序。|
/// |type|String|图片类型-中文。|
///
///
/// #### op类型信息
/// |类型|说明|
/// |-----|---|
/// |car_invoice|机动车销售发票|
/// |bank_acceptance|银行承兑汇票|
/// |train_ticket|火车票|
/// |invoice|增值税发票|
/// |air_itinerary|航空行程单|
/// |taxi_ticket|出租车发票|
/// |nontax_invoice|非税收入发票|
/// |tax_clearance_certificate|税收完税证明|
/// |used_car_invoice|二手车销售统一发票|
/// |quota_invoice|定额发票|
/// |toll_invoice|过路过桥费发票|
/// |roll_ticket|增值税发票卷票|
/// |bus_ship_ticket|客运车船票|
/// |online_taxi_itinerary|网约车行程单|
/// |common_printed_invoice|通用机打发票|
///
/// #### 结构化信息（result字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |data|object|结构化信息。|
/// |sliceRect|object|检测出的子图坐标信息。|
/// |angle|int|文字块的角度。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_mixed_invoices()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeMixedInvoicesResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |angle|int|文字块的角度。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |codes|list|二维码信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 识别结果（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |invoiceCode|string|发票代码。|
/// |invoiceNumber|string|发票号码。|
/// |invoiceDate|string|开票日期。|
/// |machineCode|string|机器编码。|
/// |checkCode|string|校验码。|
/// |purchaserName|string|受票方名称。|
/// |passwordArea|string|密码区。|
/// |invoiceAmountPreTax|string|不含税金额。|
/// |invoiceTax|string|发票税额。|
/// |totalAmountInWords|string|大写金额。|
/// |totalAmount|string|发票金额。|
/// |sellerName|string|销售方名称。|
/// |sellerTaxNumber|string|销售方税号。|
/// |sellerContactInfo|string|销售方地址、电话。|
/// |sellerBankAccountInfo|string|销售方开户行、账号。|
/// |drawer|string|开票人。|
/// |title|string|标题。|
/// |invoiceType|string|发票类型（数电专用发票、数电普通发票、电子普通发票、电子专用发票、专用发票、普通发票、通用发票）。|
/// |formType|string|联次。|
/// |printedInvoiceCode|string|机打发票代码。|
/// |printedInvoiceNumber|string|机打发票号码。|
/// |purchaserBankAccountInfo|string|受票方开户行、账号。|
/// |purchaserContactInfo|string|受票方地址、电话。|
/// |purchaserTaxNumber|string|受票方税号。|
/// |recipient|string|收款人。|
/// |remarks|string|备注。|
/// |reviewer|string|复核人。|
/// |specialTag|string|特殊标识信息。|
/// |invoiceDetails|list|发票详单。|
///
/// #### 发票详单信息（invoiceDetails字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |itemName|string|货物或应税劳务、服务名称。|
/// |specification|string|规格型号。|
/// |unit|string|单位。|
/// |quantity|string|数量。|
/// |unitPrice|string|单价。|
/// |amount|string|金额。|
/// |taxRate|string|税率。|
/// |tax|string|税额。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 二维码信息（codes字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|string|二维码地址。|
/// |type|string|二维码类型。|
/// |points|list|二维码四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
///
/// #### 识别结果（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |taxCode|string|税控码。|
/// |invoiceDate|string|开票日期。|
/// |invoiceCode|string|发票代码。|
/// |invoiceNumber|string|发票号码。|
/// |machineCode|string|机器编号。|
/// |purchaserName|string|购买方名称。|
/// |purchaseCode|string|购买方身份证号码/组织机构代码。|
/// |vehicleType|string|车辆类型。|
/// |brandMode|string|厂牌型号。|
/// |origin|string|产地。|
/// |certificateNumber|string|合格证号。|
/// |importCertificateNumber|string|进口证明书号。|
/// |commodityInspectionNumber|string|商检单号。|
/// |engineNumber|string|发动机号码。|
/// |vinCode|string|车辆识别代号/车架号码。|
/// |invoiceAmountCn|string|价税合计（大写）。|
/// |invoiceAmount|string|价税合计（小写）。|
/// |sellerName|string|销货单位名称。|
/// |sellerContact|string|销货单位电话。|
/// |sellerTaxNumber|string|销货单位纳税人识别号。|
/// |sellerBankAccount|string|销货单位账号。|
/// |sellerAddress|string|销货单位地址。|
/// |sellerDepositaryBank|string|销货单位开户银行。|
/// |taxRate|string|增值税税率或征收率。|
/// |tax|string|增值税税额。|
/// |taxAuthoritiesInfo|string|主管税务机关及代码。|
/// |taxAuthoritiesName|string|主管税务机关。|
/// |taxAuthoritiesCode|string|主管税务代码。|
/// |preTaxAmount|string|不含税价。|
/// |passengerLimitNumber|string|限乘人数。|
/// |issuer|string|开票人。|
/// |tonnage|string|吨位。|
/// |purchaserTaxNumber|string|购买方纳税人识别号。|
/// |taxPaymentNumber|string|完税凭证号码。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_car_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeCarInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 中英文字段映射
///
/// ```ignore
/// invoiceCode    发票代码
/// invoiceNumber    发票号码
/// AmountInWords    大写金额
/// Amount    小写金额
/// title    发票标题
/// formType    联次
/// ```
///
/// Return value of [Connection::recognize_quota_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeQuotaInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |agentCode|string|销售单位代号。|
/// |caacDevelopmentFund|string|民航发展基金。|
/// |endorsement|string|签注。|
/// |fare|string|票价。|
/// |flights|list|航班详单。|
/// |fuelSurcharge|string|燃油附加费。|
/// |idCardNumber|string|有效身份证号码。|
/// |insurance|string|保险费。|
/// |internationalFlightSign|string|国内国际标签。|
/// |issueCompany|string|填开单位。|
/// |issueDate|string|填开日期。|
/// |otherTaxes|string|其他税费。|
/// |passengerName|string|旅客姓名。|
/// |pnrCode|string|PNR码。|
/// |promptMessage|string|提示信息。|
/// |serialNumber|string|印刷序号。|
/// |ticketNumber|string|电子客票号码。|
/// |totalAmount|string|合计。|
/// |validationCode|string|验证码。|
///
/// #### 其他税费信息（flights字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |departureStation|string|出发站。|
/// |arrivalStation|string|到达站。|
/// |carrier|string|承运人。|
/// |flightNumber|string|航班号。|
/// |cabinClass|string|舱位等级。|
/// |flightDate|string|乘机日期。|
/// |flightTime|string|乘机时间。|
/// |seatClass|string|座位等级。|
/// |validFromDate|string|客票生效日期。|
/// |validToDate|string|有效截止日期。|
/// |freeBaggageAllowance|string|免费行李。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_air_itinerary()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeAirItineraryResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
///
/// #### 识别结果（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |departureStation|string|出发站。|
/// |arrivalStation|string|到达站。|
/// |trainNumber|string|车次。|
/// |departureTime|string|开车时间。|
/// |seatNumber|string|座位号。|
/// |fare|string|票价。|
/// |ticketGate|string|检票口。|
/// |seatType|string|座位类型。|
/// |passengerInfo|string|旅客信息。|
/// |passengerName|string|旅客姓名。|
/// |ticketNumber|string|票号。|
/// |ticketCode|string|售票码。|
/// |saleInfo|string|售票车站信息。|
/// |electronicTicketNumber|string|电子客票号。|
/// |buyerName|string|购买方名称。|
/// |buyerCreditCode|string|购买方统一信用代码。|
/// |title|string|标题。|
/// |invoiceDate|string|开票日期。|
/// |remarks|string|备注。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_train_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeTrainInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
/// |sliceRect|list|检测出的子图坐标信息。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |date|string|乘车日期。|
/// |dropOffTime|string|下车时间。|
/// |fare|string|金额。|
/// |invoiceCode|string|发票代码。|
/// |invoiceNumber|string|发票号码。|
/// |licensePlateNumber|string|车牌号。|
/// |mileage|string|里程。|
/// |pickUpTime|string|上车时间。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_taxi_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeTaxiInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 中英文字段映射
///
/// ```ignore
/// invoiceCode          发票代码
/// invoiceNumber          发票号码
/// invoiceDate          开票日期
/// checkCode          校验码
/// sellerName          销售方名称
/// sellerTaxNumber          销售方税号
/// purchaserName          购买方名称
/// purchaserTaxCode          购买方税号
/// title          标题
/// IGNORE          机打号码
/// machineCode          机器编号
/// cashier          收款员
/// totalAmountInWords          合计金额(大写)
/// totalAmount          合计金额(小写)
/// invoiceDetails          发票详单
/// itemName            项目
/// quantity            数量
/// unitPrice            单价
/// amount            金额
/// ```
///
/// Return value of [Connection::recognize_roll_ticket()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeRollTicketResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
///
/// #### 识别结果（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |issueDate|string|出票日期。|
/// |validToDate|string|到期日期。|
/// |draftStatus|string|票据状态。|
/// |draftNumber|string|票据号码。|
/// |issuerName|string|出票人全称。|
/// |issuerAccountNumber|string|出票人账号。|
/// |issuerAccountBank|string|出票人开户银行。|
/// |payeeName|string|收票人全称。|
/// |payeeAccountNumber|string|收票人账号。|
/// |payeeAccountBank|string|收票人开户银行。|
/// |totalAmountInWords|string|票据金额大写。|
/// |totalAmount|string|票据金额小写。|
/// |acceptorName|string|承兑人全称。|
/// |acceptorAccountNumber|string|承兑人账号。|
/// |acceptorBankNumber|string|承兑人开户行行号。|
/// |acceptorAccountBank|string|承兑人开户行名称。|
/// |agreementNumber|string|交易合同号。|
/// |assignability|string|能否转让。|
/// |acceptanceDate|string|承兑日期。|
/// |subDraftNumber|string|子票区间号。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_bank_acceptance()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeBankAcceptanceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// ## 中英文字段映射
/// ```ignore
/// data    结构化信息
/// prism_keyValueInfo    结构化信息的坐标信息
/// sliceRect    图片中身份证子图区域的任意四边形表示，起始点为左上角，顺序为顺时针
/// ftype    是否是复印件（1:是，0:否）
/// ```
/// *  **data**内字段说明
/// ```ignore
/// title    标题
/// formType    发票联次
/// invoiceCode    发票代码
/// invoiceNumber    发票号码
/// date    日期
/// time    时间
/// departureStation    出发车站
/// arrivalStation    到达车站
/// totalAmount    总金额
/// passengerName    姓名
/// idcardNo    身份证号
/// ```
/// * **prism_keyValueInfo数组**字段说明
/// ```ignore
/// key    识别出的字段名称
/// keyProb    字段名称置信度
/// value    识别出的字段名称对应的值
/// valueProb    字段名称对应值的置信度
/// valuePos    字段在原图中的四个点坐标（左上、右上、右下、左下）
/// ```
///
/// Return value of [Connection::recognize_bus_ship_ticket()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeBusShipTicketResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
/// |sliceRect|list|检测出的子图坐标信息。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |additionalInfo|string|其他信息。|
/// |invoiceCode|string|票据代码。|
/// |invoiceDate|string|开票日期。|
/// |invoiceDetails|list|项目详单。|
/// |invoiceNumber|string|票据号码。|
/// |payeeName|string|收款单位。|
/// |payerCreditCode|string|交款人统一社会信用代码。|
/// |payerName|string|交款人。|
/// |recipient|string|收款人。|
/// |reviewer|string|复核人。|
/// |title|string|标题。|
/// |totalAmount|string|合计金额（小写）。|
/// |totalAmountInWords|string|合计金额（大写）。|
/// |validationCode|string|校验码。|
///
/// #### 发票详单信息（invoiceDetails字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |amount|string|金额。|
/// |name|string|项目名称。|
/// |number|string|项目编号。|
/// |quantity|string|数量。|
/// |remark|string|备注。|
/// |specification|string|标准。|
/// |unit|string|单位。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_non_tax_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeNonTaxInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 中英文映射字段
///
/// ```ignore
/// title           标题
/// formType           发票联次
/// invoiceCode           发票代码
/// invoiceNumber           发票号码
/// printedInvoiceCode          发票代码-机打
/// printedInvoiceNumber           发票号码-机打
/// invoiceDate           开票日期
/// totalAmount           合计金额
/// sellerName           销售方名称
/// sellerTaxNumber           销售方纳税人识别号
/// purchaserName           购买方名称
/// purchaserTaxNumber           购买方纳税人识别号
/// drawer           开票人
/// recipient           收款人
/// remarks           备注
/// invoiceDetails           发票详单
/// itemName           项目名称
/// unit           单位
/// quantity           数量
/// unitPrice           单价
/// amount           总值
/// ftype           是否是复印件(1:是，0:否)
/// ```
///
/// Return value of [Connection::recognize_common_printed_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeCommonPrintedInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
/// fax  传真
/// phone  电话
/// postCode  邮编
/// roomNo  房号
/// checkInDate  入住日期
/// departureDate  离店日期
/// memberNumber  会员号码
/// totalConsumption  消费总计
/// name  姓名
/// roomType  房型
/// numberOfGuests  住店人数
/// roomRate  房费
/// address  地址
/// consumptionDetails  消费详单
/// --------------------------consumptionDetails数组内的字段说明--------------------------
/// date  日期
/// item  项目
/// consumption  消费
/// payment  付款
/// ```
///
/// Return value of [Connection::recognize_hotel_consume()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeHotelConsumeResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
/// |sliceRect|list|检测出的子图坐标信息。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |description|string|商品说明。|
/// |orderNumber|string|订单号。|
/// |paymentMethod|string|付款方式。|
/// |paymentTime|string|支付时间。|
/// |recipientName|string|收款方名称。|
/// |totalAmount|string|合计金额。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_payment_record()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizePaymentRecordResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
/// orderNumber  订单编号
/// transactionTime  交易时间
/// deliveryInfo  收货信息
/// totalAmount  交易金额
/// shopName  店铺名称
/// shoppingDetails  商品详单
/// ftype  是否是复印件
/// --------------------------shoppingDetails数组内的字段说明--------------------------
/// name  商品名称
/// specification  商品规格
/// price  商品单价
/// quantity  商品数量
/// ```
///
/// Return value of [Connection::recognize_purchase_record()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizePurchaseRecordResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
/// serviceProvider 服务商
/// applicationDate 申请日期
/// startTime 行程开始时间
/// endTime 行程结束时间
/// phoneNumber 行程人手机号
/// totalAmount 总金额
/// rideDetails 行程详单
/// Number 序号
/// carType 车型
/// pickUpTime 上车时间
/// city 城市
/// startPlace  起点
/// endPlace 终点
/// mileage 里程
/// amount 金额
/// remarks 备注
/// angle              角度：0-360，0表示向上，90表示向右，180表示向下，270度表示向左
/// height            算法矫正图片后的高度
/// width             算法矫正图片后的宽度
/// orgHeight      原图的高度
/// orgWidth       原图的宽度
/// ----------------------------------------prism_keyValueInfo文字块数组内的字段说明---------------------------------------
/// valuePos 外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下
/// ```
///
/// Return value of [Connection::recognize_ride_hailing_itinerary()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeRideHailingItineraryResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// ## 中英文字段映射
/// ```ignore
/// data    结构化信息
/// prism_keyValueInfo    结构化信息的坐标信息
/// ftype    是否是复印件（1:是，0:否）
/// ```
/// *  **data内字段说明**
/// ```ignore
/// shopName    开票方名称
/// receiptDate    开票日期
/// receiptTime    开票时间
/// contactNumber    联系电话
/// shopAddress    地址
/// totalAmount    合计(实付)金额
/// receiptDetails    商品详单
/// ```
/// * **prism_keyValueInfo数组**字段说明
/// ```ignore
/// key    识别出的字段名称
/// keyProb    字段名称置信度
/// value    识别出的字段名称对应的值
/// valueProb    字段名称对应值的置信度
/// valuePos    字段在原图中的四个点坐标（左上、右上、右下、左下）
/// ```
/// * **receiptDetails数组**字段说明
/// ```ignore
/// amount    小记
/// itemName    品名
/// quantity    数量
/// unitPrice   单价
/// ```
///
/// Return value of [Connection::recognize_shopping_receipt()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeShoppingReceiptResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
///
/// title          标题
/// name          姓名
/// idNumber          社会保障号码
/// cardNumber          社保保障卡号
/// bankAccount          银行账号
/// issueDate          发卡日期
/// validPeriod          有效期限
/// ftype           是否是复印件(1:是，0:否)
/// ```
///
/// Return value of [Connection::recognize_social_security_card()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeSocialSecurityCardResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 中英文映射字段
///
/// ```ignore
/// title           标题  
/// formType           联次  
/// invoiceCode           发票代码  
/// invoiceNumber           发票号码
/// date           日期  
/// time           时间  
/// vehicleType           车型
/// entranceName           入口  
/// exitName           出口
/// totalAmount          总金额
/// ftype           是否是复印件(1:是，0:否)
/// ```
///
/// Return value of [Connection::recognize_toll_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeTollInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
/// |sliceRect|list|检测出的子图坐标信息。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |certificateNumber|string|编号。|
/// |drawer|string|填票人。|
/// |formType|string|联次。|
/// |issueDate|string|填发日期。|
/// |name|string|纳税人名称。|
/// |remarks|string|备注。|
/// |taxAuthorityName|string|税务机关。|
/// |taxClearanceDetails|list|完税详单。|
/// |taxNumbe|string|纳税人识别号。|
/// |totalAmount|string|合计金额（小写）。|
/// |totalAmountInWords|string|合计金额（大写）。|
///
/// #### 完税详单（taxClearanceDetails字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |amount|string|实缴（退）金额。|
/// |date|string|入（退）库时间。|
/// |itemName|string|品目名称。|
/// |taxPeriod|string|税款所属期。|
/// |taxType|string|税种。|
/// |voucherNumber|string|原凭证号。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_tax_clearance_certificate()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeTaxClearanceCertificateResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
/// title 标题
/// formType 联次
/// invoiceDate 开票日期
/// invoiceCode 发票代码
/// invoiceNumber 发票号码
/// printedInvoiceCode 机打代码
/// printedInvoiceNumber 机打号码
/// taxCode 税控码
/// purchaserName 买方单位/个人
/// purchaserCode 买方单位代码/身份证号码
/// purchaserAddress 买方单位/个人地址
/// purchaserPhoneNumber 买方电话
/// sellerName 卖方单位/个人
/// sellerCode 卖方单位代码/身份证号码
/// sellerAddress 卖方单位/个人住址
/// sellerPhoneNumber 卖方电话
/// licensePlateNumber 车牌照号
/// certificateNumber 登记证号
/// vehicleType 车辆类型
/// vinCode 车架号/车辆识别代码
/// brandMode 厂牌型号
/// vehicleAdministrationName  转入地车辆管理所名称
/// totalAmountInWords 车价合计(大写)
/// totalAmount 车价合计(小写)
/// marketName 二手车市场名称
/// marketTaxNumber 二手车市场纳税人识别号
/// marketAddress 二手车市场地址
/// marketBankAccountInfo 二手车市场开户银行及账户
/// marketPhoneNumber 二手车市场电话
/// remarks 备注
/// drawer 开票人
///
/// angle              角度：0-360，0表示向上，90表示向右，180表示向下，270度表示向左</br>
/// height            算法矫正图片后的高度
/// width             算法矫正图片后的宽度
/// orgHeight      原图的高度
/// orgWidth       原图的宽度
/// ----------------------------------------prism_keyValueInfo文字块数组内的字段说明---------------------------------------
/// valuePos 外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下
/// ```
///
/// Return value of [Connection::recognize_used_car_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeUsedCarInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |figure|list|图片中的图案信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |creditCode|string|统一社会信用代码。|
/// |companyName|string|营业名称。|
/// |companyType|string|类型。|
/// |businessAddress|string|营业场所/住所。|
/// |legalPerson|string|法人/负责人。|
/// |businessScope|string|经营范围。|
/// |registeredCapital|string|注册资本。|
/// |RegistrationDate|string|注册日期。|
/// |validPeriod|string|营业期限。|
/// |validFromDate|string|格式化营业期限起始日期。|
/// |validToDate|string|格式化营业期限终止日期。|
/// |companyForm|string|组成形式。|
/// |issueDate|string|发照日期。|
/// |title|string|证照标题。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 图案位置信息（figure字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|图案类型。|
/// |x|int|图案左上角横坐标。|
/// |y|int|图案左上角纵坐标。|
/// |w|int|图案宽度。|
/// |h|int|图案高度。|
/// |box|object|图案坐标信息：中心横纵坐标，长宽，顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|图案四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_business_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeBusinessLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |bankAccount|string|账号。|
/// |legalRepresentative|string|法定代表人。|
/// |depositaryBank|string|开户银行。|
/// |approvalNumber|string|核准号。|
/// |customerName|string|名称。|
/// |permitNumber|string|编号。|
/// |title|string|标题。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_bank_account_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeBankAccountLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 中英文字段映射
///
/// ```ignore
/// validToDate有效期至
/// registeredAddress注册人地址
/// registrationDate注册日期
/// registrant注册人
/// approvedRightScope核定使用商品/服务项目
/// iprNumber知识产权编号
/// certificateNumber编码
/// ```
///
/// Return value of [Connection::recognize_trade_mark_certification()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeTradeMarkCertificationResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |codes|list|二维码信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |producerName|string|生产者名称。|
/// |creditCode|string|社会信用代码（身份证号码）。|
/// |legalRepresentative|string|法定代表人（负责人）。|
/// |officeAddress|string|住所。|
/// |productionAddress|string|生产地址。|
/// |foodType|string|食品类别。|
/// |licenceNumber|string|许可证编号。|
/// |regulatoryAuthority|string|日常监督管理机构。|
/// |regulatoryPersonnel|string|日常监督管理人员。|
/// |reportHotline|string|投诉举报电话。|
/// |issueAuthority|string|发证机关。|
/// |issueOfficer|string|签发人。|
/// |issueDate|string|签发日期。|
/// |validToDate|string|有效期至。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 二维码信息（codes字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|string|二维码地址。|
/// |type|string|二维码类型。|
/// |points|list|二维码四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_food_produce_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeFoodProduceLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |codes|list|二维码信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |operatorName|string|经营者名称。|
/// |creditCode|string|社会信用代码（身份证号码）。|
/// |legalRepresentative|string|法定代表人（负责人）。|
/// |officeAddress|string|住所。|
/// |businessAddress|string|经营场所。|
/// |mainBusiness|string|主体业态。|
/// |businessScope|string|经营项目。|
/// |licenceNumber|string|许可证编号。|
/// |regulatoryAuthority|string|日常监督管理机构。|
/// |regulatoryPersonnel|string|日常监督管理人员。|
/// |reportHotline|string|投诉举报电话。|
/// |issueAuthority|string|发证机关。|
/// |issueOfficer|string|签发人。|
/// |issueDate|string|签发日期。|
/// |standardizedIssueDate|string|标准化签发日期。|
/// |validToDate|string|有效期至。|
/// |standardizedValidToDate|string|标准化有效期至。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 二维码信息（codes字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|string|图案地址。|
/// |type|string|图案类型。|
/// |points|list|图案四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_food_manage_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeFoodManageLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 中英文字段映射
///
/// ```ignore
/// title证照标题
/// licenseNumber许可证编号
/// companyName企业名称
/// businessType经营方式
/// officeAddress住所
/// businessScope经营范围
/// businessAddress经营场所
/// warehouseAddress库房/仓库地址
/// issueDate发证日期
/// issueAuthority发证部门
/// legalRepresentative法定代表人
/// responsiblePerson企业负责人
/// qualityManager质量管理人
/// registeredAddress注册地址
/// validToDate有效期限/许可期限
/// ```
///
/// Return value of [Connection::recognize_medical_device_manage_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeMedicalDeviceManageLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 中英文字段映射
///
/// ```ignore
/// registeredAddress注册地址
/// issueDate发证日期
/// licenseNumber许可证编号
/// issueAuthority发证部门
/// legalRepresentative法定代表人
/// productionAddress生产地址
/// responsiblePerson企业负责人
/// companyName企业名称
/// validToDate有效期限
/// officeAddress住所
/// productionScope生产范围
/// ```
///
/// Return value of [Connection::recognize_medical_device_produce_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeMedicalDeviceProduceLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |figure|list|图片中的图案信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |recordNumber|string|备案编号。|
/// |companyName|string|企业名称。|
/// |officeAddress|string|住所。|
/// |businessAddress|string|经营场所。|
/// |warehouseAddress|string|库房地址。|
/// |businessType|string|经营方式。|
/// |legalRepresentative|string|法定代表人。|
/// |responsiblePerson|string|企业负责人。|
/// |businessScope|string|经营范围。|
/// |recordationAuthority|string|备案部门。|
/// |recordationDate|string|备案日期。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 图案位置信息（figure字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|图案类型。|
/// |x|int|图案左上角横坐标。|
/// |y|int|图案左上角纵坐标。|
/// |w|int|图案宽度。|
/// |h|int|图案高度。|
/// |box|object|图案坐标信息：中心横纵坐标，长宽，顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|图案四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_ctwo_medical_device_manage_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeCtwoMedicalDeviceManageLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明
///
/// ```ignore
/// title  证照名称
/// enterpriseName  企业名称
/// creditCode  社会信用代码
/// officeAddress  住址
/// legalRepresentative  法定代表人
/// responsiblePerson  企业负责人
/// safetyManager 质量安全负责人
/// productionAddress  生产地址
/// licenceNumber  许可证编号
/// licensedItemScope  许可项目
/// regulatoryAuthority  日常监督管理机关
/// regulatoryPersonnel  日常监督管理人员
/// reportHotline  投诉举报电话
/// issueOfficer  签发人
/// issueAuthority  发证机关
/// issueDate  发证日期
/// validToDate  有效期至
/// ftype 是否是复印件
/// ```
///
/// Return value of [Connection::recognize_cosmetic_produce_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeCosmeticProduceLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// ## 中英文字段映射
/// ```ignore
/// data  结构化信息，face（身份证正面）和 back（身份证反面）
/// prism_keyValueInfo  结构化信息的坐标信息
/// sliceRect 检测出的子图坐标信息
/// ftype    是否是复印件（1:是，0:否）
/// ```
/// *  **韩国商业登记证**字段说明
/// ```ignore
/// certificateType    证件类型
/// issuanceNo    发行号
/// processingTime    处理时间
/// companyNameEn    英文公司名称
/// companyName    非英文公司名称
/// registrationNo    商业注册号
/// nameOfRepresentativeEn    英文法人姓名
/// nameOfRepresentative    非英文法人姓名
/// residentRegistrationNo    法人证件号
/// businessAddressEn    英文商业地址
/// businessAddress    非英文商业地址
/// businessCommencementDate    商业起始时间
/// businessRegistrationDate    商业注册时间
/// businessTypeEn    英文商业类型
/// businessType    非英文商业类型
/// businessItemEn    英文经营范围
/// businessItem    非英文经营范围
/// jointCompanyName    联合企业名称
/// jointCompanyRegistrationNo    联合企业注册号
/// issueDate    签发日期
/// issuer    签发人
/// ```
/// * **印度公司注册证**字段说明
/// ```ignore
/// certificateType    证件类型
/// registrationNo    注册号
/// legalName    法定名称
/// tradeName    商号
/// businessConstitution    商业类型
/// businessAddress    地址
/// liabilityDate    责任日期
/// validFromDate    有效起始日期
/// validToDate    有效终止日期
/// registrationType    注册类型
/// particularsOfApprovingAuthority    审批机关详情
/// name    姓名
/// designation    委任
/// jurisdictionalOffice    管辖办事处
/// issueDate    签发日期
/// ```
/// * **prism_keyValueInfo数组**字段说明
/// ```ignore
/// key    识别出的字段名称
/// keyProb    字段名称置信度
/// value    识别出的字段名称对应的值
/// valueProb    字段名称对应值的置信度
/// valuePos    字段在原图中的四个点坐标（左上、右上、右下、左下）
/// ```
///
/// Return value of [Connection::recognize_international_business_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeInternationalBusinessLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息，正面为face字段，反面为back字段。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 正面识别结果（face字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |address|string|住址。|
/// |engineNumber|string|发动机号码。|
/// |issueDate|string|发证日期。|
/// |model|string|品牌型号。|
/// |owner|string|所有人。|
/// |licensePlateNumber|string|号牌号码。|
/// |registrationDate|string|注册日期。|
/// |useNature|string|使用性质。|
/// |vehicleType|string|车辆类型。|
/// |vinCode|string|车辆识别代码。|
/// |issueAuthority|string|签发机关。|
///
/// #### 反面识别结果（back字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |licensePlateNumber|string|号牌号码。|
/// |inspectionRecord|string|检验记录。|
/// |passengerCapacity|string|核定载人数。|
/// |totalWeight|string|总质量。|
/// |curbWeight|string|整备质量。|
/// |permittedWeight|string|核定载质量。|
/// |overallDimension|string|外廓尺寸。|
/// |tractionWeight|string|准牵引总质量。|
/// |energySign|string|能源标志。|
/// |recordNumber|string|档案编号。|
/// |remarks|string|备注。|
/// |barcodeNumber|string|条形码编号。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_vehicle_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeVehicleLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息，正面为face字段，反面为back字段。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 正面识别结果（face字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |licenseNumber|string|证号。|
/// |name|string|姓名。|
/// |sex|string|性别。|
/// |nationality|string|国籍。|
/// |address|string|住址。|
/// |birthDate|string|出生日期。|
/// |initialIssueDate|string|初次领证日期。|
/// |approvedType|string|准驾类型。|
/// |issueAuthority|string|发证单位。|
/// |validFromDate|string|有效起始日期。|
/// |validPeriod|string|有效期限。|
///
///
/// #### 反面识别结果（back字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |name|string|姓名。|
/// |recordNumber|string|档案编号。|
/// |record|string|记录。|
/// |licenseNumber|string|证号。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_driving_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeDrivingLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |recipientName|string|收件人姓名。|
/// |senderName|string|寄件人姓名。|
/// |senderPhoneNumber|string|寄件人电话。|
/// |senderAddress|string|寄件人地址。|
/// |recipientPhoneNumber|string|收件人电话。|
/// |recipientAddress|string|收件人地址。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_waybill()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeWaybillResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |structure_list|list|车牌信息（如果图中有多张车牌，此字段包含所有的车牌信息。数组中每条车牌数据的字段和**data**一致）。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |secondary_cls|string|车牌类型信息。|
/// |data|object|车牌信息。|
/// |info|list|结构化坐标信息。（和**prism_keyValueInfo**字段包含信息一致）。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 结构化坐标信息（info字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |key_prob|float|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |value_prob|float|字段名称对应值的置信度。|
/// |value_pos|list|车牌在原图中的四个点坐标（左上角横坐标、左上角纵坐标、右上角横坐标、右上角纵坐标、右下角横坐标、右下角纵坐标、左下角横坐标、左下角纵坐标）。|
///
/// Return value of [Connection::recognize_car_number()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeCarNumberResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |data|object|结构化信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |vinCode|string|车牌vin码信息。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_car_vin_code()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeCarVinCodeResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |codes|list|二维码信息。|
/// |sliceRect|list|检测出的子图坐标信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |acquisitionMethod|string|车辆获得方式。|
/// |axleNumber|string|轴数。|
/// |barCode|string|条形编号。|
/// |cabPassengerCapacity|string|驾驶室载客。|
/// |containerDimension|string|货箱内部尺寸。|
/// |displacement|string|排量。|
/// |engineNumber|string|发动机号。|
/// |engineType|string|发动机型号。|
/// |frontWheelTrack|string|轮距前。|
/// |fuelType|string|燃料种类。|
/// |isDomestic|string|国产/进口。|
/// |issueAuthority|string|发证机关。|
/// |issueDate|string|发证日期。|
/// |manufactureDate|string|车辆出厂日期。|
/// |manufactureName|string|制造厂名称。|
/// |overallDimension|string|外轮廓尺寸。|
/// |passengerCapacity|string|核定载客。|
/// |permittedWeight|string|核定载质量。|
/// |power|string|功率。|
/// |rearWheelTrack|string|轮距后。|
/// |registrationAuthority|string|登记机关。|
/// |registrationDate|string|登记日期。|
/// |registrationNumber|string|机动车登记编号。|
/// |springNumber|string|钢板弹簧数。|
/// |steeringForm|string|转向形式。|
/// |tireNumber|string|轮胎数。|
/// |tireSize|string|轮胎规格。|
/// |totalWeight|string|总质量。|
/// |tractionWeight|string|准牵引总质量。|
/// |useNature|string|使用性质。|
/// |vehicleBrand|string|车辆品牌。|
/// |vehicleColor|string|车身颜色。|
/// |vehicleModel|string|车辆型号。|
/// |vehicleOwnerInfo|string|机动车所有人/身份证明名称/号码。|
/// |vehicleType|string|车辆类型。|
/// |vinCode|string|车辆识别代号/车架号。|
/// |wheelbase|string|轴距。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在算法矫正后的图片中的四个点坐标（左上、右上、右下、左下）。|
///
/// #### 二维码信息（codes字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|string|二维码地址。|
/// |type|string|二维码类型。|
/// |points|list|二维码四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_vehicle_registration()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeVehicleRegistrationResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
/// |sliceRect|list|检测出的子图坐标信息。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |MaximumLoadMass|string|半挂车鞍座最大允许总质量。|
/// |axleLoad|string|轴荷。|
/// |axleNumber|string|轴数。|
/// |cabPassengerCapacity|string|驾驶室准驾人数。|
/// |certificateNumber|string|合格证编号。|
/// |chassisCertificateNumber|string|底盘合格证编号。|
/// |chassisId|string|底盘ID。|
/// |chassisModel|string|底盘型号。|
/// |containerDimension|string|货箱内部尺寸。|
/// |displacement|string|排量。|
/// |emissionStandard|string|排放标准。|
/// |engineModel|string|发动机型号。|
/// |engineNumber|string|发动机号。|
/// |equipmentWeight|string|装备质量。|
/// |frontWheelTrack|string|轮距前。|
/// |fuelConsumption|string|油耗。|
/// |fuelType|string|燃料种类。枚举值为：天然气、汽油、混合动力、柴油、纯电动|
/// |issueDate|string|发证日期。|
/// |manufactureDate|string|车辆制造日期。|
/// |manufactureName|string|车辆制造企业名称。|
/// |massUtilizationCoefficient|string|载质量利用系数。|
/// |maxDesignSpeed|string|最高设计车速。|
/// |maximumLadenMass|string|额定载质量。|
/// |overallDimension|string|外廓尺寸。|
/// |passengerCapacity|string|额定载客。|
/// |power|string|功率。|
/// |rearWheelTrack|string|轮距后。|
/// |remarks|string|备注。|
/// |springNumber|string|钢板弹簧数。|
/// |steeringForm|string|转向形式。|
/// |tireNumber|string|轮胎数。|
/// |tireSize|string|轮胎规格。|
/// |totalWeight|string|总质量。|
/// |tractionWeight|string|准牵引总质量。|
/// |vehicleBrand|string|车辆品牌。|
/// |vehicleColor|string|车身颜色。|
/// |vehicleModel|string|车辆型号。|
/// |vehicleName|string|车辆名称。|
/// |vinCode|string|车辆识别代号/车架号。|
/// |wheelbase|string|轴距。|
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_vehicle_certification()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeVehicleCertificationResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |content|string|识别出图片的文字块汇总，会包含latex公式，需要自行解析还原公式。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// Return value of [Connection::recognize_edu_formula()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEduFormulaResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |mathsInfo|list|识别出的公式内容，可能包含latex公式，需要自行解析还原。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 单字信息（mathInfos字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |pos|list|题目外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下。|
/// |result|string|口算判题结果，right：正确，wrong：错误，unknown：未知。|
/// |title|string|口算题目内容。|
///
/// Return value of [Connection::recognize_edu_oral_calculation()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEduOralCalculationResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|图片的角度。0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |content|string|识别出图片的文字块汇总，可能包含latex公式，需要自行解析还原。|
/// |figure|list|图片中的图案信息。当ImageType=scan才返回该字段。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。当NeedRotate=true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确。|
/// |word|string|文字块的文字内容。|
/// |charInfo|list|单字信息。|
///
/// #### 单字信息（charInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |word|string|单字文字。|
/// |prob|int|置信度。|
/// |recClassify|int|文字属性分类。（0：中文印刷，1：拉丁语种，2：手写体，3：韩语，4：泰文，5：公式）|
/// |x|int|单字左上角横坐标。|
/// |y|int|单字左上角纵坐标。|
/// |w|int|单字宽度。|
/// |h|int|单字高度。|
///
/// #### 图案位置信息（figure字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|图案类型。|
/// |x|int|图案左上角横坐标。|
/// |y|int|图案左上角纵坐标。|
/// |w|int|图案宽度。|
/// |h|int|图案高度。|
/// |box|object|图案坐标信息：中心横纵坐标，长宽，顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|图案四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_edu_paper_ocr()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEduPaperOcrResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
///
/// #### 页面信息（page_list字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |page_id|int|页码。|
/// |subject_list|list|题目列表。|
/// |doc_index|int|输入的文档index,默认从1开始。|
/// |angle|int|图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 题目列表信息（subject_list字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |ids|int|题号。|
/// |ismultipage|boolean|题目是否跨页。|
/// |text|int|切题后的文字信息，切题包含切题目和答案；可能包含latex公式，需要自行解析还原。|
/// |prism_wordsInfo|list|文字块信息。|
/// |content_list_info|list|内容列表。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。|
/// |word|string|文字块的文字内容。|
///
/// #### 内容信息（content_list_info字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |doc_index|int|输入的文档index,默认从1开始。|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_edu_paper_cut()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEduPaperCutResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |content|string|识别出图片的文字块汇总。|
/// |figure|list|图片中的图案信息。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。|
/// |word|string|文字块的文字内容。|
/// |charInfo|list|单字信息。|
/// |recClassify|int|文字属性分类。（0：“中文印刷”，1：“拉丁语种”，2：“手写体”，3：“韩语”，4：“泰文”，51：“公式”）。|
///
/// #### 单字信息（charInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |word|string|单字文字。|
/// |prob|int|置信度。|
/// |x|int|单字左上角横坐标。|
/// |y|int|单字左上角纵坐标。|
/// |w|int|单字宽度。|
/// |h|int|单字高度。|
///
/// #### 图案位置信息（figure字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|图案类型。|
/// |x|int|图案左上角横坐标。|
/// |y|int|图案左上角纵坐标。|
/// |w|int|图案宽度。|
/// |h|int|图案高度。|
/// |box|object|图案坐标信息：中心横纵坐标，长宽，顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|图案四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_edu_question_ocr()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEduQuestionOcrResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |doc_layout|list|版面信息。|
/// |doc_sptext|list|特殊文字信息。|
/// |figure|list|图案信息。|
/// |page_id|int|页码。|
/// |page_title|string|页标题。|
/// |part_info|list|题型大类信息。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
///
/// #### 题目列表信息（doc_layout字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |layout_type|string|文字类型（text：普通文字，special_text：特殊文字，table：表格，head：页眉，foot：页脚，side_column：侧栏）。|
/// |pos|list|外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。|
///
///
/// #### 特殊文字信息（doc_sptext字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |layout_type|string|文字类型（bold：黑体，complex：特殊体）。|
/// |pos|list|外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。|
///
///
/// #### 图案信息（figure字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|string|配图类型（subject_sline：分栏线，竖线；subject_bline：空格线/下划线，竖线；subject_bracket：括号；subject_quad：田字格和四线三格；subject_table：表格；subject_pattern：图案；subject_big_bracket：大括号；subject_match_question：连线题；subject_question：非材料题；subject_material：材料题）。|
/// |x|int|图案左上角横坐标。|
/// |y|int|图案左上角纵坐标。|
/// |w|int|图案宽度。|
/// |h|int|图案高度。|
/// |box|object|图案坐标信息：中心横纵坐标，长宽，顺时针旋转角度。定义同 OpenCV 中 RotatedRect，请参见 [OpenCV 文档](https://docs.opencv.org/3.4/db/dd6/classcv_1_1RotatedRect.html#a6bd95a46f9ab83a4f384a4d4845e6332)。|
/// |points|list|图案四个点坐标（左上、右上、右下、左下）。|
///
/// #### 题型大类信息（part_info字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |part_title|string|题型标题（例如选择题，填空题，解答题）。|
/// |pos_list|list|对应所有题型的外层大矩形的四个点的坐标数组。|
/// |subject_list|list|题目列表。|
///
///
/// #### 题目列表信息（subject_list字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |index|int|在part_info中的序号。|
/// |type|int|题目类型（0：选择题；1：填空题；2：阅读理解（阅读+问答选择）；3：完型填空（阅读+选择）；4：阅读填空（阅读+填空）；5：问答题；6：选择题，多选多；7：填空、选择题混合；8：应用题；9：判断题；10：作图题；11：材料题；12：计算题；13：连线题；14：作文题；15：解答题；16：其他；17：图；18：表格）。|
/// |text|string|整题文本信息，可能包含latex公式，需要自行解析还原。|
/// |prob|int|置信度。|
/// |post_list|list|整题外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。|
/// |answer_list|list|答案位置坐标。|
/// |element_list|list|题目元素。|
/// |figure_list|list|插图位置信息。|
/// |table_list|list|表格位置信息。|
/// |num_choices|int|选择题答案数量。|
///
/// #### 题目元素信息（element_list字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|int|题目元素类型（0：题干；1：选项；2：解析；3：答案）。|
/// |text|string|整题文本信息，可能包含latex公式，需要自行解析还原。|
/// |post_list|list|外层大矩形的四个点的坐标数组。|
/// |content_list|list|内容数组。|
///
/// #### 内容数组信息（content_list字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |type|int|内容类型（0：图片；1：文本；2：公式）。|
/// |string|string|整题文本信息，可能包含latex公式，需要自行解析还原。|
/// |pos|list|外层大矩形的四个点的坐标数组。|
///
/// Return value of [Connection::recognize_edu_paper_structed()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEduPaperStructedResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|图片的角度（当NeedRotate=true时，返回此字段）。0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |content|string|识别出图片的文字块汇总。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_tablesInfo|list|表格信息（当OutputTable=true时，返回此字段）。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。当NeedRotate=true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确。|
/// |word|string|文字块的文字内容。|
/// |tableId|int|表格的id（当OutputTable=true时，返回此字段）。|
/// |tableCellId|int|表格中单元格的id（当OutputTable=true时，返回此字段）。|
/// |charInfo|list|单字信息。|
///
/// #### 单字信息（charInfo字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |word|string|单字文字。|
/// |prob|int|置信度。|
/// |x|int|单字左上角横坐标。|
/// |y|int|单字左上角纵坐标。|
/// |w|int|单字宽度。|
/// |h|int|单字高度。|
///
/// #### 表格信息（prism_tablesInfo字段。当OutputTable=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableId|int|表格id，和prism_wordsInfo信息中的tableId对应。|
/// |xCellSize|int|表格中横坐标单元格的数量。|
/// |yCellSize|int|表格中纵坐标单元格的数量。|
/// |cellInfos|list|单元格信息。|
///
/// #### 单元格信息（cellInfos字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableCellId|int|表格中单元格id，和prism_wordsInfo信息中的tableCellId对应。|
/// |word|string|单元格中的文字。|
/// |xsc|int|xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |xec|int|xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内。|
/// |ysc|int|yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |yec|int|yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0。|
/// |pos|list|单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标。|
///
/// Return value of [Connection::recognize_multi_language()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeMultiLanguageResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|图片的角度（当NeedRotate=true时，返回此字段）。0表示正向，90表示图片朝右，180朝下，270朝左。|
/// |content|string|识别出图片的文字块汇总。|
/// |prism_wordsInfo|list|文字块信息。|
/// |prism_tablesInfo|list|表格信息（当OutputTable=true时，返回此字段）。|
/// |prism_wnum|int|识别的文字块的数量，prism_wordsInfo数组的大小。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 文字块信息（prism_wordsInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |angle|int|文字块的角度。|
/// |height|int|文字块的高度（需考虑文字块的角度）|
/// |width|int|文字块的宽度（需考虑文字块的角度）|
/// |pos|list|文字块的外矩形四个点的坐标按顺时针排列（左上、右上、右下、左下）。当NeedRotate=true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确。|
/// |word|string|文字块的文字内容。|
/// |tableId|int|表格的id（当OutputTable=true时，返回此字段）。|
/// |tableCellId|int|表格中单元格的id（当OutputTable=true时，返回此字段）。|
///
/// #### 表格信息（prism_tablesInfo字段。当OutputTable=true时，返回此字段。）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableId|int|表格id，和prism_wordsInfo信息中的tableId对应。|
/// |xCellSize|int|表格中横坐标单元格的数量。|
/// |yCellSize|int|表格中纵坐标单元格的数量。|
/// |cellInfos|list|单元格信息。|
///
/// #### 单元格信息（cellInfos字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |tableCellId|int|表格中单元格id，和prism_wordsInfo信息中的tableCellId对应。|
/// |word|string|单元格中的文字。|
/// |xsc|int|xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |xec|int|xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内。|
/// |ysc|int|yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0。|
/// |yec|int|yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0。|
/// |pos|list|单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标。|
///
/// Return value of [Connection::recognize_english()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeEnglishResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明</br>
///
/// ```ignore
/// angle                  图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左</br>
/// content              识别出图片的文字块汇总</br>
/// height                算法矫正图片后的高度</br>
/// width                 算法矫正图片后的宽度</br>
/// orgHeight          原图的高度</br>
/// orgWidth           原图的宽度</br>
/// prism_wnum      识别的文字块的数量，prism_wordsInfo数组的大小</br>
/// -------------------------prism-wordsInfo文字块数组内的字段说明-------------------------</br>
/// angle                 文字块的角度，这个角度只影响width和height，当角度为-90、90、-270、270，width和height的值需要自行互换</br>
/// height                文字块的高度</br>
/// width                 文字块的宽度</br>
/// pos                    文字块的外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下，当NeedRotate为true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确</br>
/// word                  文字块的文字</br>
/// tableId               当OutputTable为true并且该文字块在表格内则存在该字段，tableId表示表格的id</br>
/// tableCellId         当OutputTable为true并且该文字块在表格内则存在该字段，表示表格中单元格的id</br>
/// ----------------------------------------charInfo单字信息-----------------------------------------</br>
/// word                  单字文字</br>
/// x                        单字左上角横坐标</br>
/// y                        单字左上角纵坐标</br>
/// w                       单字宽度
/// <span>h                       单字高度</span></br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ---------------------------prism-tablesInfo表格数组内的字段说明--------------------------</br>
/// tableId               表格id，和prism_wordsInfo信息中的tableId对应</br>
/// xCellSize            表格中横坐标单元格的数量</br>
/// yCellSize            表格中纵坐标单元格的数量</br>
/// ------------cellInfos单元格信息，包含单元格在整个表格中的空间拓扑关系---------</br>
/// tableCellId         表格中单元格id，和prism_wordsInfo信息中的tableCellId对应</br>
/// word                 单元格中的文字</br>
/// xsc                    xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// xec                    xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内</br>
/// ysc                    yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// yec                    yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0</br>
/// pos                   单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ```
///
/// Return value of [Connection::recognize_thai()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeThaiResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明</br>
///
/// ```ignore
/// angle                  图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左</br>
/// content              识别出图片的文字块汇总</br>
/// height                算法矫正图片后的高度</br>
/// width                 算法矫正图片后的宽度</br>
/// orgHeight          原图的高度</br>
/// orgWidth           原图的宽度</br>
/// prism_wnum      识别的文字块的数量，prism_wordsInfo数组的大小</br>
/// -------------------------prism-wordsInfo文字块数组内的字段说明-------------------------</br>
/// angle                 文字块的角度，这个角度只影响width和height，当角度为-90、90、-270、270，width和height的值需要自行互换</br>
/// height                文字块的高度</br>
/// width                 文字块的宽度</br>
/// pos                    文字块的外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下，当NeedRotate为true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确</br>
/// word                  文字块的文字</br>
/// tableId               当OutputTable为true并且该文字块在表格内则存在该字段，tableId表示表格的id</br>
/// tableCellId         当OutputTable为true并且该文字块在表格内则存在该字段，表示表格中单元格的id</br>
/// ----------------------------------------charInfo单字信息-----------------------------------------</br>
/// word                  单字文字</br>
/// x                        单字左上角横坐标</br>
/// y                        单字左上角纵坐标</br>
/// w                       单字宽度
/// <span>h                       单字高度</span></br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ---------------------------prism-tablesInfo表格数组内的字段说明--------------------------</br>
/// tableId               表格id，和prism_wordsInfo信息中的tableId对应</br>
/// xCellSize            表格中横坐标单元格的数量</br>
/// yCellSize            表格中纵坐标单元格的数量</br>
/// ------------cellInfos单元格信息，包含单元格在整个表格中的空间拓扑关系---------</br>
/// tableCellId         表格中单元格id，和prism_wordsInfo信息中的tableCellId对应</br>
/// word                 单元格中的文字</br>
/// xsc                    xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// xec                    xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内</br>
/// ysc                    yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// yec                    yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0</br>
/// pos                   单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ```
///
/// Return value of [Connection::recognize_janpanese()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeJanpaneseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明</br>
///
/// ```ignore
/// angle                  图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左</br>
/// content              识别出图片的文字块汇总</br>
/// height                算法矫正图片后的高度</br>
/// width                 算法矫正图片后的宽度</br>
/// orgHeight          原图的高度</br>
/// orgWidth           原图的宽度</br>
/// prism_wnum      识别的文字块的数量，prism_wordsInfo数组的大小</br>
/// -------------------------prism-wordsInfo文字块数组内的字段说明-------------------------</br>
/// angle                 文字块的角度，这个角度只影响width和height，当角度为-90、90、-270、270，width和height的值需要自行互换</br>
/// height                文字块的高度</br>
/// width                 文字块的宽度</br>
/// pos                    文字块的外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下，当NeedRotate为true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确</br>
/// word                  文字块的文字</br>
/// tableId               当OutputTable为true并且该文字块在表格内则存在该字段，tableId表示表格的id</br>
/// tableCellId         当OutputTable为true并且该文字块在表格内则存在该字段，表示表格中单元格的id</br>
/// ----------------------------------------charInfo单字信息-----------------------------------------</br>
/// word                  单字文字</br>
/// x                        单字左上角横坐标</br>
/// y                        单字左上角纵坐标</br>
/// w                       单字宽度
/// <span>h                       单字高度</span></br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ---------------------------prism-tablesInfo表格数组内的字段说明--------------------------</br>
/// tableId               表格id，和prism_wordsInfo信息中的tableId对应</br>
/// xCellSize            表格中横坐标单元格的数量</br>
/// yCellSize            表格中纵坐标单元格的数量</br>
/// ------------cellInfos单元格信息，包含单元格在整个表格中的空间拓扑关系---------</br>
/// tableCellId         表格中单元格id，和prism_wordsInfo信息中的tableCellId对应</br>
/// word                 单元格中的文字</br>
/// xsc                    xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// xec                    xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内</br>
/// ysc                    yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// yec                    yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0</br>
/// pos                   单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ```
///
/// Return value of [Connection::recognize_korean()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeKoreanResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明</br>
///
/// ```ignore
/// angle                  图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左</br>
/// content              识别出图片的文字块汇总</br>
/// height                算法矫正图片后的高度</br>
/// width                 算法矫正图片后的宽度</br>
/// orgHeight          原图的高度</br>
/// orgWidth           原图的宽度</br>
/// prism_wnum      识别的文字块的数量，prism_wordsInfo数组的大小</br>
/// -------------------------prism-wordsInfo文字块数组内的字段说明-------------------------</br>
/// angle                 文字块的角度，这个角度只影响width和height，当角度为-90、90、-270、270，width和height的值需要自行互换</br>
/// height                文字块的高度</br>
/// width                 文字块的宽度</br>
/// pos                    文字块的外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下，当NeedRotate为true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确</br>
/// word                  文字块的文字</br>
/// tableId               当OutputTable为true并且该文字块在表格内则存在该字段，tableId表示表格的id</br>
/// tableCellId         当OutputTable为true并且该文字块在表格内则存在该字段，表示表格中单元格的id</br>
/// ----------------------------------------charInfo单字信息-----------------------------------------</br>
/// word                  单字文字</br>
/// x                        单字左上角横坐标</br>
/// y                        单字左上角纵坐标</br>
/// w                       单字宽度
/// <span>h                       单字高度</span></br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ---------------------------prism-tablesInfo表格数组内的字段说明--------------------------</br>
/// tableId               表格id，和prism_wordsInfo信息中的tableId对应</br>
/// xCellSize            表格中横坐标单元格的数量</br>
/// yCellSize            表格中纵坐标单元格的数量</br>
/// ------------cellInfos单元格信息，包含单元格在整个表格中的空间拓扑关系---------</br>
/// tableCellId         表格中单元格id，和prism_wordsInfo信息中的tableCellId对应</br>
/// word                 单元格中的文字</br>
/// xsc                    xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// xec                    xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内</br>
/// ysc                    yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// yec                    yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0</br>
/// pos                   单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ```
///
/// Return value of [Connection::recognize_latin()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeLatinResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// 返回数据说明</br>
///
/// ```ignore
/// angle                  图片的角度，0表示正向，90表示图片朝右，180朝下，270朝左</br>
/// content              识别出图片的文字块汇总</br>
/// height                算法矫正图片后的高度</br>
/// width                 算法矫正图片后的宽度</br>
/// orgHeight          原图的高度</br>
/// orgWidth           原图的宽度</br>
/// prism_wnum      识别的文字块的数量，prism_wordsInfo数组的大小</br>
/// -------------------------prism-wordsInfo文字块数组内的字段说明-------------------------</br>
/// angle                 文字块的角度，这个角度只影响width和height，当角度为-90、90、-270、270，width和height的值需要自行互换</br>
/// height                文字块的高度</br>
/// width                 文字块的宽度</br>
/// pos                    文字块的外矩形四个点的坐标按顺时针排列，左上、右上、右下、左下，当NeedRotate为true时，如果最外层的angle不为0，需要按照angle矫正图片后，坐标才准确</br>
/// word                  文字块的文字</br>
/// tableId               当OutputTable为true并且该文字块在表格内则存在该字段，tableId表示表格的id</br>
/// tableCellId         当OutputTable为true并且该文字块在表格内则存在该字段，表示表格中单元格的id</br>
/// ----------------------------------------charInfo单字信息-----------------------------------------</br>
/// word                  单字文字</br>
/// x                        单字左上角横坐标</br>
/// y                        单字左上角纵坐标</br>
/// w                       单字宽度
/// <span>h                       单字高度</span></br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ---------------------------prism-tablesInfo表格数组内的字段说明--------------------------</br>
/// tableId               表格id，和prism_wordsInfo信息中的tableId对应</br>
/// xCellSize            表格中横坐标单元格的数量</br>
/// yCellSize            表格中纵坐标单元格的数量</br>
/// ------------cellInfos单元格信息，包含单元格在整个表格中的空间拓扑关系---------</br>
/// tableCellId         表格中单元格id，和prism_wordsInfo信息中的tableCellId对应</br>
/// word                 单元格中的文字</br>
/// xsc                    xStartCell缩写，表示横轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// xec                    xEndCell缩写，表示横轴方向该单元格结束在第几个单元格，第一个单元格值为0，如果xsc和xec都为0说明该文字在横轴方向占据了一个单元格并且在第一个单元格内</br>
/// ysc                    yStartCell缩写，表示纵轴方向该单元格起始在第几个单元格，第一个单元格值为0</br>
/// yec                    yEndCell缩写，表示纵轴方向该单元格结束在第几个单元格，第一个单元格值为0</br>
/// pos                   单元格位置，按照单元格四个角的坐标顺时针排列，分别为左上XY坐标、右上XY坐标、右下XY坐标、左下XY坐标</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// --------------------------------------------------------------------------------------------------------</br>
/// ```
///
/// Return value of [Connection::recognize_russian()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeRussianResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// #### 返回参数说明
/// <br/>
///
/// |字段|类型|说明|
/// |-----|---|--|
/// |data|object|结构化信息。|
/// |sliceRect|list|结构化信息的坐标信息。|
/// |prism_keyValueInfo|list|结构化信息的坐标信息。|
/// |ftype|int|是否为复印件（1：是，0：否）。|
/// |height|int|算法矫正图片后的高度。|
/// |width|int|算法矫正图片后的宽度。|
/// |orgHeight|int|原图的高度。|
/// |orgWidth|int|原图的宽度。|
///
/// #### 结构化信息（data字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |name|string|姓名。|
/// |idNumber|string|证件号码。|
/// |samplingDate|string|采样日期。|
/// |samplingTime|string|采样时间。|
/// |testOrganization|string|检测机构。|
/// |testItem|string|检测项目。|
/// |testResult|string|检测结果。|
///
///
/// #### 结构化坐标信息（prism_keyValueInfo字段）
/// |字段|类型|说明|
/// |-----|---|--|
/// |key|string|识别出的字段名称。|
/// |keyProb|int|字段名称置信度。|
/// |value|string|识别出的字段名称对应的值。|
/// |valueProb|int|字段名称对应值的置信度。|
/// |valuePos|list|字段在原图中的四个点坐标（左上、右上、右下、左下）。|
///
/// Return value of [Connection::recognize_covid_test_report()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct RecognizeCovidTestReportResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// <br/>
/// * <span style="font-size:larger;"> <b> 返回结果字段描述 </b></span>
///   
/// |字段名称|字段类型|描述|枚举值|
/// |-------|------|---|------|
/// | code | string | 状态码| 0、20001、20002、20003 |
/// | data | bool | 三要素信息是否一致| true：一致 <br/>false：不一致|
/// | message| string | 状态信息|（1）法人姓名、工商注册号一致 <br/> （2）此公司在数据库中不存在！<br/> （3） 输入的法人名字和公司法人名字不一致！<br/>（4）传入的注册号与工商注册号和统一社会信用代码都不一致！|
///
/// * <span style="font-size:larger;"> <b>code（状态码）、message（状态信息）、data（核验结果是否一致）对应关系</b> </span>
///   
/// |code|data|message|
/// |---|---|----|
/// |0|true|法人姓名、工商注册号一致|
/// |20001|false|此公司在数据库中不存在！|
/// |20002|false|输入的法人名字和公司法人名字不一致！|
/// |20003|false|传入的注册号与工商注册号和统一社会信用代码都不一致！|
///
/// Return value of [Connection::verify_business_license()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct VerifyBusinessLicenseResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}
/// * **返回结果字段描述**
///
/// |字段名称|字段类型|描述|
/// |-------|------|---|
/// |code   |string|状态码|
/// |msg    |string|状态信息|
/// |data   |string|发票信息（只有查验成功，此字段才不为空）|
///
/// * <span style="font-size:larger;"> <b> 返回结果data字段描述（非区块链发票)</b></span>
///   
/// |序号|字段名称|字段描述|字段类型|字段最大长度|是否一定返回|说明|
/// |---|-------|-------|------|-------|----|----|
/// |1|invoiceType|发票种类|string|2|是||
/// |2|invoiceCode|发票代码|string|20|是||
/// |3|invoiceNumber|发票号码|string|8|是||
/// |4|inspectionAmount|查验次数|string|100|否||
/// |5|salerName|销方名称|string|100|否||
/// |6|salerTaxpayerNumber|销方税号|string|20|否||
/// |7|salerAddressOrPhone|销方地址、电话|string|100|否||
/// |8|salerBankAndNumber|销方开户行及账号|string|100|否||
/// |9|purchaserTaxpayerNumber|购方税号|string|20|否||
/// |10|purchaserName|购方名称|string|100|否||
/// |11|purchaserAddressOrPhone|购方地址、电话|string|100|否||
/// |12|purchaserBankAndNumber|购方开户行及账号|string|100|否||
/// |13|invoiceDate|开票日期|string|8|否|格式：yyyymmdd|
/// |14|invoiceMoney|发票金额|string|20|否||
/// |15|allTax|发票税额|string|20|否||
/// |16|allValoremTax|价税合计|string|16|否||
/// |17|note|备注|string|200|否||
/// |18|machineCode|机器编号|string|20|否||
/// |19|checkCode|校验码|string|20|否||
/// |20|blueInvoiceCode|蓝票发票代码|string|12|否||
/// |21|blueInvoiceNo|蓝票发票号码|string|8|否||
/// |22|invalidMark|作废标志|string|1|否|N：未作废，Y：已作废，H：冲红，7：部分冲红，8：全额冲红|
/// |23|idCard|购方身份证号/组织机构代码|string|20|否|机动车、二手车发票返回该信息|
/// |24|carType|车辆类型|string|80|否|机动车、二手车发票返回该信息|
/// |25|brandVersion|厂牌型号|string|100|否|机动车、二手车发票返回该信息|
/// |26|producingArea|产地|string|80|否|机动车发票返回该信息|
/// |27|licenseCode|合格证号|string|100|否|机动车发票返回该信息|
/// |28|inspectionNumber|商检单号|string|80|否|机动车发票返回该信息|
/// |29|engineCode|发动机号|string|120|否|机动车发票返回该信息|
/// |30|carframeCode|车辆识别代号/车架号码|string|40|否|机动车、二手车发票返回该信息|
/// |31|importLicense|进口证明书号|string|80|否|机动车发票返回该信息|
/// |32|taxUnitCode|主管税务机关代码|string|11|否|机动车发票返回该信息|
/// |33|afterTaxCode|完税凭证号码|string|32|否|机动车发票返回该信息|
/// |34|limitAmount|限乘人数|string|40|否|机动车发票返回该信息|
/// |35|taxUnitName|主管税务机关名称|string|160|否|机动车发票返回该信息|
/// |36|unit|吨位|string|40|否|机动车发票返回该信息|
/// |37|taxRate|税率|string|32|否|机动车发票返回该信息|
/// |38|salerAddress|销方地址|string|160|否|机动车发票返回该信息|
/// |39|salerPhone|销方电话|string|80|否|机动车发票返回该信息|
/// |40|salerBankName|销方开户银行|string|160|否|机动车发票返回该信息|
/// |41|salerBankAccount|销方开户账号|string|80|否|机动车发票返回该信息|
/// |42|carrierName|承运人名称|string|20|否|货物发票返回信息|
/// |43|carrierTaxNo|承运人识别号|string|80|否|货物发票返回信息|
/// |44|draweeName|受票方名称|string|20|否|货物发票返回信息|
/// |45|draweeTaxNo|受票方识别号|string|80|否|货物发票返回信息|
/// |46|receiveName|收货人名称|string|20|否|货物发票返回信息|
/// |47|receiveTaxNo|收货人识别号|string|80|否|货物发票返回信息|
/// |48|consignorName|发货人名称|string|20|否|货物发票返回信息|
/// |49|consignorTaxNo|发货人识别号|string|80|否|货物发票返回信息|
/// |50|transportGoodsInfo|运输货物信息|string|32|否|货物发票返回信息|
/// |51|throughAddress|起运地、经由、到达地|string|32|否|货物发票返回信息|
/// |52|taxDiskNumber|税控盘号|string|32|否|货物发票返回信息|
/// |53|carTypeAndNumber|车种车号|string|15|否|货物发票返回信息|
/// |54|vehicleTonnage|车船吨位|string|200|否|货物发票返回信息|
/// |55|trafficFeeFlag|通行费标准|string|2|否|通行费发票返回信息<br/>Y：可抵扣通行费。N：不可抵扣通行费|
/// |56|zeroTaxRateFlag|零税率标识|string|2|否|通行费发票返回信息为空表示非零税率<br/>1：税率栏位显示“免税”<br/>2：税率栏位显示“不征税”<br/>3：零税率|
/// |57|licensePlate|车牌照号|string|100|否|二手车发票返回信息|
/// |58|registrationNo|登记证号|string|100|否|二手车发票返回信息|
/// |59|carPrice|车价合计|string|32|否|二手车发票返回信息|
/// |60|transferredVehicleOffice|转入地车辆车管所名称|string|240|否|二手车发票返回信息|
/// |61|purchaserUnitOrIndividual|买方单位/个人|string|240|否|二手车发票返回信息|
/// |62|purchaserUnitcodeOrIdno|买方单位代码/身份证号|string|44|否|二手车发票返回信息|
/// |63|purchaserUnitOrIndividualAddress|买方单位/个人住址|string|240|否|二手车发票返回信息|
/// |64|purchaserPhone|买方电话|string|100|否|二手车发票返回信息|
/// |65|sellerUnitOrIndividual|卖方单位/个人|string|240|否|二手车发票返回信息|
/// |66|sellerUnitCodeOrIdno|卖方单位代码/身份证号|string|44|否|二手车发票返回信息|
/// |67|sellerUnitOrIndividualAddress|卖方单位/个人住址|string|240|否|二手车发票返回信息|
/// |68|sellerPhone|卖方电话|string|100|否|二手车发票返回信息|
/// |69|businessUnit|经营、拍卖单位|string|240|否|二手车发票返回信息|
/// |70|busmessUnitAddress|经营、拍卖单位地址|string|240|否|二手车发票返回信息|
/// |71|businessUnitTaxNo|经营、拍卖单位纳税人识别号|string|44|否|二手车发票返回信息|
/// |72|busmessUnitBankAndAccount|开户银行及账号|string|100|否|二手车发票返回信息|
/// |73|busmessUnitPhone|经营、拍卖单位电话|string|100|否|二手车发票返回信息|
/// |74|lemonMarket|二手车市场|string|240|否|二手车发票返回信息|
/// |75|lemonMarketTaxNo|二手车市场纳税人识别号|string|44|否|二手车发票返回信息|
/// |76|lemonMarketAddress|二手车市场地址|string|240|否|二手车发票返回信息|
/// |77|lemonMarketBankAndAccount|二手车市场开户银行及账号|string|100|否|二手车发票返回信息|
/// |78|lemonMarketPhone|二手车市场电话|string|100|否|二手车发票返回信息|
/// |79|cyjgxx|验真结果|string|100|否|验真结果|
///
/// * <span style="font-size:larger;"> <b> 返回结果data字段描述（区块链发票）</b></span>
///   
/// |序号|字段名称|字段描述|字段类型|说明|
/// |---|-------|-------|------|----|
/// |1|invoiceCode|发票代码|string||
/// |2|invoiceNo|发票号码|string||
/// |3|checkCode|校验码|string||
/// |4|billingDate|开票日期|string||
/// |5|txHash|交易哈希|string||
/// |6|amount|不含税总金额|string||
/// |7|totalAmount|含税总金额|string||
/// |8|taxAmount|税额|string||
/// |9|sellerName|销方名称|string||
/// |10|sellerTaxpayerId|销方纳税人识别号|string||
/// |11|sellerAddress|销方地址|string||
/// |12|sellerPhone|销方电话|string||
/// |13|sellerBankInfo|销方开户银行名称|string||
/// |14|buyerAddress|购方地址|string||
/// |15|buyerPhone|购方电话|string||
/// |16|buyerName|购方名称|string||
/// |17|sellerBankAccount|销方开户银行账号|string||
/// |18|buyerTaxpayerId|购方纳税人识别号|string||
/// |19|buyerType|购买方类型|string||
/// |20|status|发票状态|string|0：正常，1：失控，2：作废，3：红冲，4：异常|
/// |21|checkedBy|复核人|string||
/// |22|reviewedBy|审核人|string||
/// |23|remark|开票备注|string||
/// |24|drawer|开票人|string||
/// |25|time|开票时间|string||
/// |26|platformCode|平台编码|string||
/// |27|platformName|平台名称|string||
/// |28|orderId|订单流水号|string||
/// |29|payId|支付流水号|string||
/// |30|digitPaymentSign|电子支付标识|string||
/// |31|invalidMark|是否作废|string||
/// |32|item|发票明细集合|list|（以下为 **item** 字段的说明）|
/// |1|+code|货物或应税劳务、服务编码|string||
/// |2|+name|货物或应税劳务、服务名称|string||
/// |3|+subName|商品名称|string||
/// |4|+specModel|规格型号|string||
/// |5|+unit|计量单位|string||
/// |6|+count|数量|string||
/// |7|+unitPrice|单价|string||
/// |8|+amount|金额|string||
/// |9|+taxFlag|含税标记|string||
/// |10|+taxRate|税率|string||
/// |11|+taxAmount|税额|string||
/// |12|+taxPreferMark|是否享受税收优惠标识|string||
/// |13|+taxPreferDescrip|享受税收优惠的具体说明|string||
/// |14|+zeroTaxRateMark|零税率标识|string||
/// |15|+deduction|差额开票时，从总额中扣除的金额|string||
///
/// * <span style="font-size:larger;"> <b> 返回结果detailList字段描述</b></span>
///   
/// |序号|字段名称|字段描述|字段类型|说明|
/// |---|-------|-------|------|----|
/// |1|detailNo|明细编号|string||
/// |2|goodsName|货物名称|string||
/// |3|detailAmount|金额|string||
/// |4|num|数量|string||
/// |5|taxRate|税率|string||
/// |6|allTax|税额|string||
/// |7|taxUnitPrice|含税单价|string||
/// |8|taxDetailAmount|含税金额|string||
/// |9|netValue|不含税单价|string||
/// |10|standard|规格型号|string||
/// |11|unit|计量单位|string||
/// |12|expenseItem|费用项目|string|货物发票返回信息|
/// |13|plate_no|车牌号|string|通行费发票返回信息|
/// |14|type|类型|string|通行费发票返回信息|
/// |15|trafficDateStart|通行日期起|string|通行费发票返回信息|
/// |16|trafficDateEnd|通行日期止|string|通行费发票返回信息|
/// |17|taxClassifyCode|税收分类编码|string||
/// |18|rowNo|行号|string||
///
/// * **code（状态码）和msg（状态信息）对应关系，以及是否计费说明**
///
/// |code|msg|是否计费|
/// |-------|------|---|
/// |001|成功|**是**|
/// |002|超过该张票当天查验次数|否|
/// |005|请求不合法|否|
/// |006|发票信息不一致|**是**|
/// |009|所查发票不存在|**是**|
/// |104|已超过最大查验量|否|
/// |105|查询发票不规范。可能是以下原因导致：<ul> <li> 接口参数传入不完整或错误。</li> <li> 发票类型不支持（例如区块链发票）。</li> <li> 发票不是真实有效的。</li></ul>|否|
/// |106|查验异常|否|
/// |108|参数不为空|否|
/// |109|参数长度不正确|否|
/// |110|参数"InvoiceCode"的格式或取值范围错误|否|
/// |111|参数"InvoiceSum"的格式或取值范围错误|否|
/// |112|参数"VerifyCode"的格式或取值范围错误|否|
/// |113|参数"InvoiceNo"的格式或取值范围错误|否|
/// |114|校验码不正确，应为后六位|否|
/// |115|超过服务有效期限限制|否|
/// |1005|请核对四要素是否符合发票规范|**是**|
/// |1010|日期格式不正确(请检查日期是否符合格式YYYYMMDD)|否|
/// |1011|请求参数不完整|否|
/// |1021|网络超时，税局升级维护|否|
/// |10014|日期当天不能查验|否|
/// |10015|开票金额：不合法的格式|否|
/// |10016|检验码：不能为空|否|
/// |10017|超过五年的不能查验|否|
/// |10018|检验码：不合法的长度|否|
/// |10020|没有查验权限|否|
/// |000000|成功|**是**|
/// |000001|查询无数据|否|
/// |101000|系统异常|否|
/// |111000|参数不能为空|否|
/// |111001|参数格式不正确|否|
/// |121000|内部处理失败|否|
/// |121001|内部处理限流|否|
/// |121002|内部处理超时|否|
/// |131002|接口无权限|否|
/// |131003|接口调用次数过限|否|
/// |131004|接口已到期|否|
/// |131005|接口调用频率过高|否|
/// |152000|超过用户QPS调用阈值|否|
/// |171000|数据源业务异常|否|
///
/// Return value of [Connection::verify_vat_invoice()].
#[derive(Debug, Default, serde::Deserialize)]
pub struct VerifyVATInvoiceResponse {
    #[serde(flatten)]
    pub code_message: crate::CodeMessage,
    /// 请求唯一 ID
    #[serde(rename = "RequestId")]
    pub request_id: Option<String>,
    /// 返回数据
    #[serde(rename = "Data")]
    pub data: Option<String>,
}

crate::impl_to_code_message!(
    RecognizeAllTextResponse,
    RecognizeGeneralStructureResponse,
    RecognizeAdvancedResponse,
    RecognizeHandwritingResponse,
    RecognizeBasicResponse,
    RecognizeGeneralResponse,
    RecognizeTableOcrResponse,
    RecognizeHealthCodeResponse,
    RecognizeDocumentStructureResponse,
    RecognizeIdcardResponse,
    RecognizePassportResponse,
    RecognizeHouseholdResponse,
    RecognizeEstateCertificationResponse,
    RecognizeBankCardResponse,
    RecognizeBirthCertificationResponse,
    RecognizeChinesePassportResponse,
    RecognizeExitEntryPermitToMainlandResponse,
    RecognizeExitEntryPermitToHKResponse,
    RecognizeHKIdcardResponse,
    RecognizeSocialSecurityCardVersionIIResponse,
    RecognizeInternationalIdcardResponse,
    RecognizeMixedInvoicesResponse,
    RecognizeInvoiceResponse,
    RecognizeCarInvoiceResponse,
    RecognizeQuotaInvoiceResponse,
    RecognizeAirItineraryResponse,
    RecognizeTrainInvoiceResponse,
    RecognizeTaxiInvoiceResponse,
    RecognizeRollTicketResponse,
    RecognizeBankAcceptanceResponse,
    RecognizeBusShipTicketResponse,
    RecognizeNonTaxInvoiceResponse,
    RecognizeCommonPrintedInvoiceResponse,
    RecognizeHotelConsumeResponse,
    RecognizePaymentRecordResponse,
    RecognizePurchaseRecordResponse,
    RecognizeRideHailingItineraryResponse,
    RecognizeShoppingReceiptResponse,
    RecognizeSocialSecurityCardResponse,
    RecognizeTollInvoiceResponse,
    RecognizeTaxClearanceCertificateResponse,
    RecognizeUsedCarInvoiceResponse,
    RecognizeBusinessLicenseResponse,
    RecognizeBankAccountLicenseResponse,
    RecognizeTradeMarkCertificationResponse,
    RecognizeFoodProduceLicenseResponse,
    RecognizeFoodManageLicenseResponse,
    RecognizeMedicalDeviceManageLicenseResponse,
    RecognizeMedicalDeviceProduceLicenseResponse,
    RecognizeCtwoMedicalDeviceManageLicenseResponse,
    RecognizeCosmeticProduceLicenseResponse,
    RecognizeInternationalBusinessLicenseResponse,
    RecognizeVehicleLicenseResponse,
    RecognizeDrivingLicenseResponse,
    RecognizeWaybillResponse,
    RecognizeCarNumberResponse,
    RecognizeCarVinCodeResponse,
    RecognizeVehicleRegistrationResponse,
    RecognizeVehicleCertificationResponse,
    RecognizeEduFormulaResponse,
    RecognizeEduOralCalculationResponse,
    RecognizeEduPaperOcrResponse,
    RecognizeEduPaperCutResponse,
    RecognizeEduQuestionOcrResponse,
    RecognizeEduPaperStructedResponse,
    RecognizeMultiLanguageResponse,
    RecognizeEnglishResponse,
    RecognizeThaiResponse,
    RecognizeJanpaneseResponse,
    RecognizeKoreanResponse,
    RecognizeLatinResponse,
    RecognizeRussianResponse,
    RecognizeCovidTestReportResponse,
    VerifyBusinessLicenseResponse,
    VerifyVATInvoiceResponse
);
