ocr

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 25, 2023 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

View Source 
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source 
var EndpointType = "regional"

EndpointType regional or central

Functions ¶

func GetEndpointMap ¶ 

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType ¶ 

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty ¶ 

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient ¶ 

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types ¶

type AddressFifthLine ¶ 

type AddressFifthLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

AddressFifthLine is a nested struct in ocr response

type AddressFirstLine ¶ 

type AddressFirstLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

AddressFirstLine is a nested struct in ocr response

type AddressFourthLine ¶ 

type AddressFourthLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

AddressFourthLine is a nested struct in ocr response

type AddressSecondLine ¶ 

type AddressSecondLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

AddressSecondLine is a nested struct in ocr response

type AddressThirdLine ¶ 

type AddressThirdLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

AddressThirdLine is a nested struct in ocr response

type Addresses ¶ 

type Addresses struct {
	Address []string `json:"Address" xml:"Address"`
}

Addresses is a nested struct in ocr response

type AuxiliaryTools ¶ 

type AuxiliaryTools struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

AuxiliaryTools is a nested struct in ocr response

type BackResult ¶ 

type BackResult struct {
	Name                      string `json:"Name" xml:"Name"`
	Issue                     string `json:"Issue" xml:"Issue"`
	ApprovedLoad              string `json:"ApprovedLoad" xml:"ApprovedLoad"`
	EndDate                   string `json:"EndDate" xml:"EndDate"`
	PlateNumber               string `json:"PlateNumber" xml:"PlateNumber"`
	EnergyType                string `json:"EnergyType" xml:"EnergyType"`
	StartDate                 string `json:"StartDate" xml:"StartDate"`
	OverallDimension          string `json:"OverallDimension" xml:"OverallDimension"`
	Record                    string `json:"Record" xml:"Record"`
	TractionMass              string `json:"TractionMass" xml:"TractionMass"`
	InspectionRecord          string `json:"InspectionRecord" xml:"InspectionRecord"`
	UnladenMass               string `json:"UnladenMass" xml:"UnladenMass"`
	ArchiveNumber             string `json:"ArchiveNumber" xml:"ArchiveNumber"`
	FileNumber                string `json:"FileNumber" xml:"FileNumber"`
	ApprovedPassengerCapacity string `json:"ApprovedPassengerCapacity" xml:"ApprovedPassengerCapacity"`
	GrossMass                 string `json:"GrossMass" xml:"GrossMass"`
	CardNumber                string `json:"CardNumber" xml:"CardNumber"`
}

BackResult is a nested struct in ocr response

type BandBoxes ¶ 

type BandBoxes struct {
	BandBox []float64 `json:"BandBox" xml:"BandBox"`
}

BandBoxes is a nested struct in ocr response

type BirthDate ¶ 

type BirthDate struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthDate is a nested struct in ocr response

type BirthDateInRecognizeRussiaIdentityCard ¶ 

type BirthDateInRecognizeRussiaIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthDateInRecognizeRussiaIdentityCard is a nested struct in ocr response

type BirthDateInRecognizeTurkeyIdentityCard ¶ 

type BirthDateInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthDateInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type BirthDateInRecognizeUkraineIdentityCard ¶ 

type BirthDateInRecognizeUkraineIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthDateInRecognizeUkraineIdentityCard is a nested struct in ocr response

type BirthDateInRecognizeVietnamIdentityCard ¶ 

type BirthDateInRecognizeVietnamIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthDateInRecognizeVietnamIdentityCard is a nested struct in ocr response

type BirthPlace ¶ 

type BirthPlace struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthPlace is a nested struct in ocr response

type BirthPlaceFirstLine ¶ 

type BirthPlaceFirstLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthPlaceFirstLine is a nested struct in ocr response

type BirthPlaceInRecognizeTurkeyIdentityCard ¶ 

type BirthPlaceInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthPlaceInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type BirthPlaceSecondLine ¶ 

type BirthPlaceSecondLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthPlaceSecondLine is a nested struct in ocr response

type BirthPlaceThirdLine ¶ 

type BirthPlaceThirdLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BirthPlaceThirdLine is a nested struct in ocr response

type BloodType ¶ 

type BloodType struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

BloodType is a nested struct in ocr response

type Box ¶ 

type Box struct {
	PayerRegisterNoes []float64 `json:"PayerRegisterNoes" xml:"PayerRegisterNoes"`
	PayeeAddresses    []float64 `json:"PayeeAddresses" xml:"PayeeAddresses"`
	PayeeBankNames    []float64 `json:"PayeeBankNames" xml:"PayeeBankNames"`
	Checkers          []float64 `json:"Checkers" xml:"Checkers"`
	TaxAmounts        []float64 `json:"TaxAmounts" xml:"TaxAmounts"`
	SumAmounts        []float64 `json:"SumAmounts" xml:"SumAmounts"`
	Clerks            []float64 `json:"Clerks" xml:"Clerks"`
	InvoiceNoes       []float64 `json:"InvoiceNoes" xml:"InvoiceNoes"`
	InvoiceDates      []float64 `json:"InvoiceDates" xml:"InvoiceDates"`
	InvoiceCodes      []float64 `json:"InvoiceCodes" xml:"InvoiceCodes"`
	InvoiceFakeCodes  []float64 `json:"InvoiceFakeCodes" xml:"InvoiceFakeCodes"`
	PayerNames        []float64 `json:"PayerNames" xml:"PayerNames"`
	PayerBankNames    []float64 `json:"PayerBankNames" xml:"PayerBankNames"`
	Payees            []float64 `json:"Payees" xml:"Payees"`
	PayeeNames        []float64 `json:"PayeeNames" xml:"PayeeNames"`
	InvoiceAmounts    []float64 `json:"InvoiceAmounts" xml:"InvoiceAmounts"`
	WithoutTaxAmounts []float64 `json:"WithoutTaxAmounts" xml:"WithoutTaxAmounts"`
	PayerAddresses    []float64 `json:"PayerAddresses" xml:"PayerAddresses"`
	PayeeRegisterNoes []float64 `json:"PayeeRegisterNoes" xml:"PayeeRegisterNoes"`
	ItemNames         []int     `json:"ItemNames" xml:"ItemNames"`
}

Box is a nested struct in ocr response

type Boxes ¶ 

type Boxes struct {
	Box []int `json:"Box" xml:"Box"`
}

Boxes is a nested struct in ocr response

type CardArea ¶ 

type CardArea struct {
	Y float64 `json:"Y" xml:"Y"`
	X float64 `json:"X" xml:"X"`
}

CardArea is a nested struct in ocr response

type CardAreas ¶ 

type CardAreas struct {
	CardArea []CardArea `json:"CardArea" xml:"CardArea"`
}

CardAreas is a nested struct in ocr response

type CardBox ¶ 

type CardBox struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

CardBox is a nested struct in ocr response

type CardBoxInRecognizeTurkeyIdentityCard ¶ 

type CardBoxInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

CardBoxInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type CardBoxInRecognizeUkraineIdentityCard ¶ 

type CardBoxInRecognizeUkraineIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

CardBoxInRecognizeUkraineIdentityCard is a nested struct in ocr response

type CellPhoneNumbers ¶ 

type CellPhoneNumbers struct {
	CellPhoneNumber []string `json:"CellPhoneNumber" xml:"CellPhoneNumber"`
}

CellPhoneNumbers is a nested struct in ocr response

type Center ¶ 

type Center struct {
	X float64 `json:"X" xml:"X"`
	Y float64 `json:"Y" xml:"Y"`
}

Center is a nested struct in ocr response

type Checkers ¶ 

type Checkers struct {
	Checker []float64 `json:"Checker" xml:"Checker"`
}

Checkers is a nested struct in ocr response

type Cilt ¶ 

type Cilt struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Cilt is a nested struct in ocr response

type Clerks ¶ 

type Clerks struct {
	Clerk []float64 `json:"Clerk" xml:"Clerk"`
}

Clerks is a nested struct in ocr response

type Client ¶ 

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient ¶ 

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey ¶ 

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole ¶ 

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions ¶ 

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider ¶ 

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn ¶ 

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy ¶ 

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair ¶ 

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken ¶ 

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) DetectCardScreenshot ¶ 

func (client *Client) DetectCardScreenshot(request *DetectCardScreenshotRequest) (response *DetectCardScreenshotResponse, err error)

DetectCardScreenshot invokes the ocr.DetectCardScreenshot API synchronously

func (*Client) DetectCardScreenshotWithCallback ¶ 

func (client *Client) DetectCardScreenshotWithCallback(request *DetectCardScreenshotRequest, callback func(response *DetectCardScreenshotResponse, err error)) <-chan int

DetectCardScreenshotWithCallback invokes the ocr.DetectCardScreenshot API asynchronously

func (*Client) DetectCardScreenshotWithChan ¶ 

func (client *Client) DetectCardScreenshotWithChan(request *DetectCardScreenshotRequest) (<-chan *DetectCardScreenshotResponse, <-chan error)

DetectCardScreenshotWithChan invokes the ocr.DetectCardScreenshot API asynchronously

func (*Client) GetAsyncJobResult ¶ 

func (client *Client) GetAsyncJobResult(request *GetAsyncJobResultRequest) (response *GetAsyncJobResultResponse, err error)

GetAsyncJobResult invokes the ocr.GetAsyncJobResult API synchronously

func (*Client) GetAsyncJobResultWithCallback ¶ 

func (client *Client) GetAsyncJobResultWithCallback(request *GetAsyncJobResultRequest, callback func(response *GetAsyncJobResultResponse, err error)) <-chan int

GetAsyncJobResultWithCallback invokes the ocr.GetAsyncJobResult API asynchronously

func (*Client) GetAsyncJobResultWithChan ¶ 

func (client *Client) GetAsyncJobResultWithChan(request *GetAsyncJobResultRequest) (<-chan *GetAsyncJobResultResponse, <-chan error)

GetAsyncJobResultWithChan invokes the ocr.GetAsyncJobResult API asynchronously

func (*Client) RecognizeAccountPage ¶ 

func (client *Client) RecognizeAccountPage(request *RecognizeAccountPageRequest) (response *RecognizeAccountPageResponse, err error)

RecognizeAccountPage invokes the ocr.RecognizeAccountPage API synchronously

func (*Client) RecognizeAccountPageWithCallback ¶ 

func (client *Client) RecognizeAccountPageWithCallback(request *RecognizeAccountPageRequest, callback func(response *RecognizeAccountPageResponse, err error)) <-chan int

RecognizeAccountPageWithCallback invokes the ocr.RecognizeAccountPage API asynchronously

func (*Client) RecognizeAccountPageWithChan ¶ 

func (client *Client) RecognizeAccountPageWithChan(request *RecognizeAccountPageRequest) (<-chan *RecognizeAccountPageResponse, <-chan error)

RecognizeAccountPageWithChan invokes the ocr.RecognizeAccountPage API asynchronously

func (*Client) RecognizeBankCard ¶ 

func (client *Client) RecognizeBankCard(request *RecognizeBankCardRequest) (response *RecognizeBankCardResponse, err error)

RecognizeBankCard invokes the ocr.RecognizeBankCard API synchronously

func (*Client) RecognizeBankCardWithCallback ¶ 

func (client *Client) RecognizeBankCardWithCallback(request *RecognizeBankCardRequest, callback func(response *RecognizeBankCardResponse, err error)) <-chan int

RecognizeBankCardWithCallback invokes the ocr.RecognizeBankCard API asynchronously

func (*Client) RecognizeBankCardWithChan ¶ 

func (client *Client) RecognizeBankCardWithChan(request *RecognizeBankCardRequest) (<-chan *RecognizeBankCardResponse, <-chan error)

RecognizeBankCardWithChan invokes the ocr.RecognizeBankCard API asynchronously

func (*Client) RecognizeBusinessCard ¶ 

func (client *Client) RecognizeBusinessCard(request *RecognizeBusinessCardRequest) (response *RecognizeBusinessCardResponse, err error)

RecognizeBusinessCard invokes the ocr.RecognizeBusinessCard API synchronously

func (*Client) RecognizeBusinessCardWithCallback ¶ 

func (client *Client) RecognizeBusinessCardWithCallback(request *RecognizeBusinessCardRequest, callback func(response *RecognizeBusinessCardResponse, err error)) <-chan int

RecognizeBusinessCardWithCallback invokes the ocr.RecognizeBusinessCard API asynchronously

func (*Client) RecognizeBusinessCardWithChan ¶ 

func (client *Client) RecognizeBusinessCardWithChan(request *RecognizeBusinessCardRequest) (<-chan *RecognizeBusinessCardResponse, <-chan error)

RecognizeBusinessCardWithChan invokes the ocr.RecognizeBusinessCard API asynchronously

func (*Client) RecognizeBusinessLicense ¶ 

func (client *Client) RecognizeBusinessLicense(request *RecognizeBusinessLicenseRequest) (response *RecognizeBusinessLicenseResponse, err error)

RecognizeBusinessLicense invokes the ocr.RecognizeBusinessLicense API synchronously

func (*Client) RecognizeBusinessLicenseWithCallback ¶ 

func (client *Client) RecognizeBusinessLicenseWithCallback(request *RecognizeBusinessLicenseRequest, callback func(response *RecognizeBusinessLicenseResponse, err error)) <-chan int

RecognizeBusinessLicenseWithCallback invokes the ocr.RecognizeBusinessLicense API asynchronously

func (*Client) RecognizeBusinessLicenseWithChan ¶ 

func (client *Client) RecognizeBusinessLicenseWithChan(request *RecognizeBusinessLicenseRequest) (<-chan *RecognizeBusinessLicenseResponse, <-chan error)

RecognizeBusinessLicenseWithChan invokes the ocr.RecognizeBusinessLicense API asynchronously

func (*Client) RecognizeCharacter ¶ 

func (client *Client) RecognizeCharacter(request *RecognizeCharacterRequest) (response *RecognizeCharacterResponse, err error)

RecognizeCharacter invokes the ocr.RecognizeCharacter API synchronously

func (*Client) RecognizeCharacterWithCallback ¶ 

func (client *Client) RecognizeCharacterWithCallback(request *RecognizeCharacterRequest, callback func(response *RecognizeCharacterResponse, err error)) <-chan int

RecognizeCharacterWithCallback invokes the ocr.RecognizeCharacter API asynchronously

func (*Client) RecognizeCharacterWithChan ¶ 

func (client *Client) RecognizeCharacterWithChan(request *RecognizeCharacterRequest) (<-chan *RecognizeCharacterResponse, <-chan error)

RecognizeCharacterWithChan invokes the ocr.RecognizeCharacter API asynchronously

func (*Client) RecognizeChinapassport ¶ 

func (client *Client) RecognizeChinapassport(request *RecognizeChinapassportRequest) (response *RecognizeChinapassportResponse, err error)

RecognizeChinapassport invokes the ocr.RecognizeChinapassport API synchronously

func (*Client) RecognizeChinapassportWithCallback ¶ 

func (client *Client) RecognizeChinapassportWithCallback(request *RecognizeChinapassportRequest, callback func(response *RecognizeChinapassportResponse, err error)) <-chan int

RecognizeChinapassportWithCallback invokes the ocr.RecognizeChinapassport API asynchronously

func (*Client) RecognizeChinapassportWithChan ¶ 

func (client *Client) RecognizeChinapassportWithChan(request *RecognizeChinapassportRequest) (<-chan *RecognizeChinapassportResponse, <-chan error)

RecognizeChinapassportWithChan invokes the ocr.RecognizeChinapassport API asynchronously

func (*Client) RecognizeDriverLicense ¶ 

func (client *Client) RecognizeDriverLicense(request *RecognizeDriverLicenseRequest) (response *RecognizeDriverLicenseResponse, err error)

RecognizeDriverLicense invokes the ocr.RecognizeDriverLicense API synchronously

func (*Client) RecognizeDriverLicenseWithCallback ¶ 

func (client *Client) RecognizeDriverLicenseWithCallback(request *RecognizeDriverLicenseRequest, callback func(response *RecognizeDriverLicenseResponse, err error)) <-chan int

RecognizeDriverLicenseWithCallback invokes the ocr.RecognizeDriverLicense API asynchronously

func (*Client) RecognizeDriverLicenseWithChan ¶ 

func (client *Client) RecognizeDriverLicenseWithChan(request *RecognizeDriverLicenseRequest) (<-chan *RecognizeDriverLicenseResponse, <-chan error)

RecognizeDriverLicenseWithChan invokes the ocr.RecognizeDriverLicense API asynchronously

func (*Client) RecognizeDrivingLicense ¶ 

func (client *Client) RecognizeDrivingLicense(request *RecognizeDrivingLicenseRequest) (response *RecognizeDrivingLicenseResponse, err error)

RecognizeDrivingLicense invokes the ocr.RecognizeDrivingLicense API synchronously

func (*Client) RecognizeDrivingLicenseWithCallback ¶ 

func (client *Client) RecognizeDrivingLicenseWithCallback(request *RecognizeDrivingLicenseRequest, callback func(response *RecognizeDrivingLicenseResponse, err error)) <-chan int

RecognizeDrivingLicenseWithCallback invokes the ocr.RecognizeDrivingLicense API asynchronously

func (*Client) RecognizeDrivingLicenseWithChan ¶ 

func (client *Client) RecognizeDrivingLicenseWithChan(request *RecognizeDrivingLicenseRequest) (<-chan *RecognizeDrivingLicenseResponse, <-chan error)

RecognizeDrivingLicenseWithChan invokes the ocr.RecognizeDrivingLicense API asynchronously

func (*Client) RecognizeIdentityCard ¶ 

func (client *Client) RecognizeIdentityCard(request *RecognizeIdentityCardRequest) (response *RecognizeIdentityCardResponse, err error)

RecognizeIdentityCard invokes the ocr.RecognizeIdentityCard API synchronously

func (*Client) RecognizeIdentityCardWithCallback ¶ 

func (client *Client) RecognizeIdentityCardWithCallback(request *RecognizeIdentityCardRequest, callback func(response *RecognizeIdentityCardResponse, err error)) <-chan int

RecognizeIdentityCardWithCallback invokes the ocr.RecognizeIdentityCard API asynchronously

func (*Client) RecognizeIdentityCardWithChan ¶ 

func (client *Client) RecognizeIdentityCardWithChan(request *RecognizeIdentityCardRequest) (<-chan *RecognizeIdentityCardResponse, <-chan error)

RecognizeIdentityCardWithChan invokes the ocr.RecognizeIdentityCard API asynchronously

func (*Client) RecognizeIndonesiaIdentityCard ¶ 

func (client *Client) RecognizeIndonesiaIdentityCard(request *RecognizeIndonesiaIdentityCardRequest) (response *RecognizeIndonesiaIdentityCardResponse, err error)

RecognizeIndonesiaIdentityCard invokes the ocr.RecognizeIndonesiaIdentityCard API synchronously

func (*Client) RecognizeIndonesiaIdentityCardWithCallback ¶ 

func (client *Client) RecognizeIndonesiaIdentityCardWithCallback(request *RecognizeIndonesiaIdentityCardRequest, callback func(response *RecognizeIndonesiaIdentityCardResponse, err error)) <-chan int

RecognizeIndonesiaIdentityCardWithCallback invokes the ocr.RecognizeIndonesiaIdentityCard API asynchronously

func (*Client) RecognizeIndonesiaIdentityCardWithChan ¶ 

func (client *Client) RecognizeIndonesiaIdentityCardWithChan(request *RecognizeIndonesiaIdentityCardRequest) (<-chan *RecognizeIndonesiaIdentityCardResponse, <-chan error)

RecognizeIndonesiaIdentityCardWithChan invokes the ocr.RecognizeIndonesiaIdentityCard API asynchronously

func (*Client) RecognizeLicensePlate ¶ 

func (client *Client) RecognizeLicensePlate(request *RecognizeLicensePlateRequest) (response *RecognizeLicensePlateResponse, err error)

RecognizeLicensePlate invokes the ocr.RecognizeLicensePlate API synchronously

func (*Client) RecognizeLicensePlateWithCallback ¶ 

func (client *Client) RecognizeLicensePlateWithCallback(request *RecognizeLicensePlateRequest, callback func(response *RecognizeLicensePlateResponse, err error)) <-chan int

RecognizeLicensePlateWithCallback invokes the ocr.RecognizeLicensePlate API asynchronously

func (*Client) RecognizeLicensePlateWithChan ¶ 

func (client *Client) RecognizeLicensePlateWithChan(request *RecognizeLicensePlateRequest) (<-chan *RecognizeLicensePlateResponse, <-chan error)

RecognizeLicensePlateWithChan invokes the ocr.RecognizeLicensePlate API asynchronously

func (*Client) RecognizeMalaysiaIdentityCard ¶ 

func (client *Client) RecognizeMalaysiaIdentityCard(request *RecognizeMalaysiaIdentityCardRequest) (response *RecognizeMalaysiaIdentityCardResponse, err error)

RecognizeMalaysiaIdentityCard invokes the ocr.RecognizeMalaysiaIdentityCard API synchronously

func (*Client) RecognizeMalaysiaIdentityCardWithCallback ¶ 

func (client *Client) RecognizeMalaysiaIdentityCardWithCallback(request *RecognizeMalaysiaIdentityCardRequest, callback func(response *RecognizeMalaysiaIdentityCardResponse, err error)) <-chan int

RecognizeMalaysiaIdentityCardWithCallback invokes the ocr.RecognizeMalaysiaIdentityCard API asynchronously

func (*Client) RecognizeMalaysiaIdentityCardWithChan ¶ 

func (client *Client) RecognizeMalaysiaIdentityCardWithChan(request *RecognizeMalaysiaIdentityCardRequest) (<-chan *RecognizeMalaysiaIdentityCardResponse, <-chan error)

RecognizeMalaysiaIdentityCardWithChan invokes the ocr.RecognizeMalaysiaIdentityCard API asynchronously

func (*Client) RecognizePassportMRZ ¶ 

func (client *Client) RecognizePassportMRZ(request *RecognizePassportMRZRequest) (response *RecognizePassportMRZResponse, err error)

RecognizePassportMRZ invokes the ocr.RecognizePassportMRZ API synchronously

func (*Client) RecognizePassportMRZWithCallback ¶ 

func (client *Client) RecognizePassportMRZWithCallback(request *RecognizePassportMRZRequest, callback func(response *RecognizePassportMRZResponse, err error)) <-chan int

RecognizePassportMRZWithCallback invokes the ocr.RecognizePassportMRZ API asynchronously

func (*Client) RecognizePassportMRZWithChan ¶ 

func (client *Client) RecognizePassportMRZWithChan(request *RecognizePassportMRZRequest) (<-chan *RecognizePassportMRZResponse, <-chan error)

RecognizePassportMRZWithChan invokes the ocr.RecognizePassportMRZ API asynchronously

func (*Client) RecognizePdf ¶ 

func (client *Client) RecognizePdf(request *RecognizePdfRequest) (response *RecognizePdfResponse, err error)

RecognizePdf invokes the ocr.RecognizePdf API synchronously

func (*Client) RecognizePdfWithCallback ¶ 

func (client *Client) RecognizePdfWithCallback(request *RecognizePdfRequest, callback func(response *RecognizePdfResponse, err error)) <-chan int

RecognizePdfWithCallback invokes the ocr.RecognizePdf API asynchronously

func (*Client) RecognizePdfWithChan ¶ 

func (client *Client) RecognizePdfWithChan(request *RecognizePdfRequest) (<-chan *RecognizePdfResponse, <-chan error)

RecognizePdfWithChan invokes the ocr.RecognizePdf API asynchronously

func (*Client) RecognizePoiName ¶ 

func (client *Client) RecognizePoiName(request *RecognizePoiNameRequest) (response *RecognizePoiNameResponse, err error)

RecognizePoiName invokes the ocr.RecognizePoiName API synchronously

func (*Client) RecognizePoiNameWithCallback ¶ 

func (client *Client) RecognizePoiNameWithCallback(request *RecognizePoiNameRequest, callback func(response *RecognizePoiNameResponse, err error)) <-chan int

RecognizePoiNameWithCallback invokes the ocr.RecognizePoiName API asynchronously

func (*Client) RecognizePoiNameWithChan ¶ 

func (client *Client) RecognizePoiNameWithChan(request *RecognizePoiNameRequest) (<-chan *RecognizePoiNameResponse, <-chan error)

RecognizePoiNameWithChan invokes the ocr.RecognizePoiName API asynchronously

func (*Client) RecognizeQrCode ¶ 

func (client *Client) RecognizeQrCode(request *RecognizeQrCodeRequest) (response *RecognizeQrCodeResponse, err error)

RecognizeQrCode invokes the ocr.RecognizeQrCode API synchronously

func (*Client) RecognizeQrCodeWithCallback ¶ 

func (client *Client) RecognizeQrCodeWithCallback(request *RecognizeQrCodeRequest, callback func(response *RecognizeQrCodeResponse, err error)) <-chan int

RecognizeQrCodeWithCallback invokes the ocr.RecognizeQrCode API asynchronously

func (*Client) RecognizeQrCodeWithChan ¶ 

func (client *Client) RecognizeQrCodeWithChan(request *RecognizeQrCodeRequest) (<-chan *RecognizeQrCodeResponse, <-chan error)

RecognizeQrCodeWithChan invokes the ocr.RecognizeQrCode API asynchronously

func (*Client) RecognizeQuotaInvoice ¶ 

func (client *Client) RecognizeQuotaInvoice(request *RecognizeQuotaInvoiceRequest) (response *RecognizeQuotaInvoiceResponse, err error)

RecognizeQuotaInvoice invokes the ocr.RecognizeQuotaInvoice API synchronously

func (*Client) RecognizeQuotaInvoiceWithCallback ¶ 

func (client *Client) RecognizeQuotaInvoiceWithCallback(request *RecognizeQuotaInvoiceRequest, callback func(response *RecognizeQuotaInvoiceResponse, err error)) <-chan int

RecognizeQuotaInvoiceWithCallback invokes the ocr.RecognizeQuotaInvoice API asynchronously

func (*Client) RecognizeQuotaInvoiceWithChan ¶ 

func (client *Client) RecognizeQuotaInvoiceWithChan(request *RecognizeQuotaInvoiceRequest) (<-chan *RecognizeQuotaInvoiceResponse, <-chan error)

RecognizeQuotaInvoiceWithChan invokes the ocr.RecognizeQuotaInvoice API asynchronously

func (*Client) RecognizeRussiaIdentityCard ¶ 

func (client *Client) RecognizeRussiaIdentityCard(request *RecognizeRussiaIdentityCardRequest) (response *RecognizeRussiaIdentityCardResponse, err error)

RecognizeRussiaIdentityCard invokes the ocr.RecognizeRussiaIdentityCard API synchronously

func (*Client) RecognizeRussiaIdentityCardWithCallback ¶ 

func (client *Client) RecognizeRussiaIdentityCardWithCallback(request *RecognizeRussiaIdentityCardRequest, callback func(response *RecognizeRussiaIdentityCardResponse, err error)) <-chan int

RecognizeRussiaIdentityCardWithCallback invokes the ocr.RecognizeRussiaIdentityCard API asynchronously

func (*Client) RecognizeRussiaIdentityCardWithChan ¶ 

func (client *Client) RecognizeRussiaIdentityCardWithChan(request *RecognizeRussiaIdentityCardRequest) (<-chan *RecognizeRussiaIdentityCardResponse, <-chan error)

RecognizeRussiaIdentityCardWithChan invokes the ocr.RecognizeRussiaIdentityCard API asynchronously

func (*Client) RecognizeStamp ¶ 

func (client *Client) RecognizeStamp(request *RecognizeStampRequest) (response *RecognizeStampResponse, err error)

RecognizeStamp invokes the ocr.RecognizeStamp API synchronously

func (*Client) RecognizeStampWithCallback ¶ 

func (client *Client) RecognizeStampWithCallback(request *RecognizeStampRequest, callback func(response *RecognizeStampResponse, err error)) <-chan int

RecognizeStampWithCallback invokes the ocr.RecognizeStamp API asynchronously

func (*Client) RecognizeStampWithChan ¶ 

func (client *Client) RecognizeStampWithChan(request *RecognizeStampRequest) (<-chan *RecognizeStampResponse, <-chan error)

RecognizeStampWithChan invokes the ocr.RecognizeStamp API asynchronously

func (*Client) RecognizeTable ¶ 

func (client *Client) RecognizeTable(request *RecognizeTableRequest) (response *RecognizeTableResponse, err error)

RecognizeTable invokes the ocr.RecognizeTable API synchronously

func (*Client) RecognizeTableWithCallback ¶ 

func (client *Client) RecognizeTableWithCallback(request *RecognizeTableRequest, callback func(response *RecognizeTableResponse, err error)) <-chan int

RecognizeTableWithCallback invokes the ocr.RecognizeTable API asynchronously

func (*Client) RecognizeTableWithChan ¶ 

func (client *Client) RecognizeTableWithChan(request *RecognizeTableRequest) (<-chan *RecognizeTableResponse, <-chan error)

RecognizeTableWithChan invokes the ocr.RecognizeTable API asynchronously

func (*Client) RecognizeTakeoutOrder ¶ 

func (client *Client) RecognizeTakeoutOrder(request *RecognizeTakeoutOrderRequest) (response *RecognizeTakeoutOrderResponse, err error)

RecognizeTakeoutOrder invokes the ocr.RecognizeTakeoutOrder API synchronously

func (*Client) RecognizeTakeoutOrderWithCallback ¶ 

func (client *Client) RecognizeTakeoutOrderWithCallback(request *RecognizeTakeoutOrderRequest, callback func(response *RecognizeTakeoutOrderResponse, err error)) <-chan int

RecognizeTakeoutOrderWithCallback invokes the ocr.RecognizeTakeoutOrder API asynchronously

func (*Client) RecognizeTakeoutOrderWithChan ¶ 

func (client *Client) RecognizeTakeoutOrderWithChan(request *RecognizeTakeoutOrderRequest) (<-chan *RecognizeTakeoutOrderResponse, <-chan error)

RecognizeTakeoutOrderWithChan invokes the ocr.RecognizeTakeoutOrder API asynchronously

func (*Client) RecognizeTaxiInvoice ¶ 

func (client *Client) RecognizeTaxiInvoice(request *RecognizeTaxiInvoiceRequest) (response *RecognizeTaxiInvoiceResponse, err error)

RecognizeTaxiInvoice invokes the ocr.RecognizeTaxiInvoice API synchronously

func (*Client) RecognizeTaxiInvoiceWithCallback ¶ 

func (client *Client) RecognizeTaxiInvoiceWithCallback(request *RecognizeTaxiInvoiceRequest, callback func(response *RecognizeTaxiInvoiceResponse, err error)) <-chan int

RecognizeTaxiInvoiceWithCallback invokes the ocr.RecognizeTaxiInvoice API asynchronously

func (*Client) RecognizeTaxiInvoiceWithChan ¶ 

func (client *Client) RecognizeTaxiInvoiceWithChan(request *RecognizeTaxiInvoiceRequest) (<-chan *RecognizeTaxiInvoiceResponse, <-chan error)

RecognizeTaxiInvoiceWithChan invokes the ocr.RecognizeTaxiInvoice API asynchronously

func (*Client) RecognizeTicketInvoice ¶ 

func (client *Client) RecognizeTicketInvoice(request *RecognizeTicketInvoiceRequest) (response *RecognizeTicketInvoiceResponse, err error)

RecognizeTicketInvoice invokes the ocr.RecognizeTicketInvoice API synchronously

func (*Client) RecognizeTicketInvoiceWithCallback ¶ 

func (client *Client) RecognizeTicketInvoiceWithCallback(request *RecognizeTicketInvoiceRequest, callback func(response *RecognizeTicketInvoiceResponse, err error)) <-chan int

RecognizeTicketInvoiceWithCallback invokes the ocr.RecognizeTicketInvoice API asynchronously

func (*Client) RecognizeTicketInvoiceWithChan ¶ 

func (client *Client) RecognizeTicketInvoiceWithChan(request *RecognizeTicketInvoiceRequest) (<-chan *RecognizeTicketInvoiceResponse, <-chan error)

RecognizeTicketInvoiceWithChan invokes the ocr.RecognizeTicketInvoice API asynchronously

func (*Client) RecognizeTrainTicket ¶ 

func (client *Client) RecognizeTrainTicket(request *RecognizeTrainTicketRequest) (response *RecognizeTrainTicketResponse, err error)

RecognizeTrainTicket invokes the ocr.RecognizeTrainTicket API synchronously

func (*Client) RecognizeTrainTicketWithCallback ¶ 

func (client *Client) RecognizeTrainTicketWithCallback(request *RecognizeTrainTicketRequest, callback func(response *RecognizeTrainTicketResponse, err error)) <-chan int

RecognizeTrainTicketWithCallback invokes the ocr.RecognizeTrainTicket API asynchronously

func (*Client) RecognizeTrainTicketWithChan ¶ 

func (client *Client) RecognizeTrainTicketWithChan(request *RecognizeTrainTicketRequest) (<-chan *RecognizeTrainTicketResponse, <-chan error)

RecognizeTrainTicketWithChan invokes the ocr.RecognizeTrainTicket API asynchronously

func (*Client) RecognizeTurkeyIdentityCard ¶ 

func (client *Client) RecognizeTurkeyIdentityCard(request *RecognizeTurkeyIdentityCardRequest) (response *RecognizeTurkeyIdentityCardResponse, err error)

RecognizeTurkeyIdentityCard invokes the ocr.RecognizeTurkeyIdentityCard API synchronously

func (*Client) RecognizeTurkeyIdentityCardWithCallback ¶ 

func (client *Client) RecognizeTurkeyIdentityCardWithCallback(request *RecognizeTurkeyIdentityCardRequest, callback func(response *RecognizeTurkeyIdentityCardResponse, err error)) <-chan int

RecognizeTurkeyIdentityCardWithCallback invokes the ocr.RecognizeTurkeyIdentityCard API asynchronously

func (*Client) RecognizeTurkeyIdentityCardWithChan ¶ 

func (client *Client) RecognizeTurkeyIdentityCardWithChan(request *RecognizeTurkeyIdentityCardRequest) (<-chan *RecognizeTurkeyIdentityCardResponse, <-chan error)

RecognizeTurkeyIdentityCardWithChan invokes the ocr.RecognizeTurkeyIdentityCard API asynchronously

func (*Client) RecognizeUkraineIdentityCard ¶ 

func (client *Client) RecognizeUkraineIdentityCard(request *RecognizeUkraineIdentityCardRequest) (response *RecognizeUkraineIdentityCardResponse, err error)

RecognizeUkraineIdentityCard invokes the ocr.RecognizeUkraineIdentityCard API synchronously

func (*Client) RecognizeUkraineIdentityCardWithCallback ¶ 

func (client *Client) RecognizeUkraineIdentityCardWithCallback(request *RecognizeUkraineIdentityCardRequest, callback func(response *RecognizeUkraineIdentityCardResponse, err error)) <-chan int

RecognizeUkraineIdentityCardWithCallback invokes the ocr.RecognizeUkraineIdentityCard API asynchronously

func (*Client) RecognizeUkraineIdentityCardWithChan ¶ 

func (client *Client) RecognizeUkraineIdentityCardWithChan(request *RecognizeUkraineIdentityCardRequest) (<-chan *RecognizeUkraineIdentityCardResponse, <-chan error)

RecognizeUkraineIdentityCardWithChan invokes the ocr.RecognizeUkraineIdentityCard API asynchronously

func (*Client) RecognizeVATInvoice ¶ 

func (client *Client) RecognizeVATInvoice(request *RecognizeVATInvoiceRequest) (response *RecognizeVATInvoiceResponse, err error)

RecognizeVATInvoice invokes the ocr.RecognizeVATInvoice API synchronously

func (*Client) RecognizeVATInvoiceWithCallback ¶ 

func (client *Client) RecognizeVATInvoiceWithCallback(request *RecognizeVATInvoiceRequest, callback func(response *RecognizeVATInvoiceResponse, err error)) <-chan int

RecognizeVATInvoiceWithCallback invokes the ocr.RecognizeVATInvoice API asynchronously

func (*Client) RecognizeVATInvoiceWithChan ¶ 

func (client *Client) RecognizeVATInvoiceWithChan(request *RecognizeVATInvoiceRequest) (<-chan *RecognizeVATInvoiceResponse, <-chan error)

RecognizeVATInvoiceWithChan invokes the ocr.RecognizeVATInvoice API asynchronously

func (*Client) RecognizeVINCode ¶ 

func (client *Client) RecognizeVINCode(request *RecognizeVINCodeRequest) (response *RecognizeVINCodeResponse, err error)

RecognizeVINCode invokes the ocr.RecognizeVINCode API synchronously

func (*Client) RecognizeVINCodeWithCallback ¶ 

func (client *Client) RecognizeVINCodeWithCallback(request *RecognizeVINCodeRequest, callback func(response *RecognizeVINCodeResponse, err error)) <-chan int

RecognizeVINCodeWithCallback invokes the ocr.RecognizeVINCode API asynchronously

func (*Client) RecognizeVINCodeWithChan ¶ 

func (client *Client) RecognizeVINCodeWithChan(request *RecognizeVINCodeRequest) (<-chan *RecognizeVINCodeResponse, <-chan error)

RecognizeVINCodeWithChan invokes the ocr.RecognizeVINCode API asynchronously

func (*Client) RecognizeVerificationcode ¶ 

func (client *Client) RecognizeVerificationcode(request *RecognizeVerificationcodeRequest) (response *RecognizeVerificationcodeResponse, err error)

RecognizeVerificationcode invokes the ocr.RecognizeVerificationcode API synchronously

func (*Client) RecognizeVerificationcodeWithCallback ¶ 

func (client *Client) RecognizeVerificationcodeWithCallback(request *RecognizeVerificationcodeRequest, callback func(response *RecognizeVerificationcodeResponse, err error)) <-chan int

RecognizeVerificationcodeWithCallback invokes the ocr.RecognizeVerificationcode API asynchronously

func (*Client) RecognizeVerificationcodeWithChan ¶ 

func (client *Client) RecognizeVerificationcodeWithChan(request *RecognizeVerificationcodeRequest) (<-chan *RecognizeVerificationcodeResponse, <-chan error)

RecognizeVerificationcodeWithChan invokes the ocr.RecognizeVerificationcode API asynchronously

func (*Client) RecognizeVideoCastCrewList ¶ 

func (client *Client) RecognizeVideoCastCrewList(request *RecognizeVideoCastCrewListRequest) (response *RecognizeVideoCastCrewListResponse, err error)

RecognizeVideoCastCrewList invokes the ocr.RecognizeVideoCastCrewList API synchronously

func (*Client) RecognizeVideoCastCrewListWithCallback ¶ 

func (client *Client) RecognizeVideoCastCrewListWithCallback(request *RecognizeVideoCastCrewListRequest, callback func(response *RecognizeVideoCastCrewListResponse, err error)) <-chan int

RecognizeVideoCastCrewListWithCallback invokes the ocr.RecognizeVideoCastCrewList API asynchronously

func (*Client) RecognizeVideoCastCrewListWithChan ¶ 

func (client *Client) RecognizeVideoCastCrewListWithChan(request *RecognizeVideoCastCrewListRequest) (<-chan *RecognizeVideoCastCrewListResponse, <-chan error)

RecognizeVideoCastCrewListWithChan invokes the ocr.RecognizeVideoCastCrewList API asynchronously

func (*Client) RecognizeVideoCharacter ¶ 

func (client *Client) RecognizeVideoCharacter(request *RecognizeVideoCharacterRequest) (response *RecognizeVideoCharacterResponse, err error)

RecognizeVideoCharacter invokes the ocr.RecognizeVideoCharacter API synchronously

func (*Client) RecognizeVideoCharacterWithCallback ¶ 

func (client *Client) RecognizeVideoCharacterWithCallback(request *RecognizeVideoCharacterRequest, callback func(response *RecognizeVideoCharacterResponse, err error)) <-chan int

RecognizeVideoCharacterWithCallback invokes the ocr.RecognizeVideoCharacter API asynchronously

func (*Client) RecognizeVideoCharacterWithChan ¶ 

func (client *Client) RecognizeVideoCharacterWithChan(request *RecognizeVideoCharacterRequest) (<-chan *RecognizeVideoCharacterResponse, <-chan error)

RecognizeVideoCharacterWithChan invokes the ocr.RecognizeVideoCharacter API asynchronously

func (*Client) RecognizeVietnamIdentityCard ¶ 

func (client *Client) RecognizeVietnamIdentityCard(request *RecognizeVietnamIdentityCardRequest) (response *RecognizeVietnamIdentityCardResponse, err error)

RecognizeVietnamIdentityCard invokes the ocr.RecognizeVietnamIdentityCard API synchronously

func (*Client) RecognizeVietnamIdentityCardWithCallback ¶ 

func (client *Client) RecognizeVietnamIdentityCardWithCallback(request *RecognizeVietnamIdentityCardRequest, callback func(response *RecognizeVietnamIdentityCardResponse, err error)) <-chan int

RecognizeVietnamIdentityCardWithCallback invokes the ocr.RecognizeVietnamIdentityCard API asynchronously

func (*Client) RecognizeVietnamIdentityCardWithChan ¶ 

func (client *Client) RecognizeVietnamIdentityCardWithChan(request *RecognizeVietnamIdentityCardRequest) (<-chan *RecognizeVietnamIdentityCardResponse, <-chan error)

RecognizeVietnamIdentityCardWithChan invokes the ocr.RecognizeVietnamIdentityCard API asynchronously

func (*Client) TrimDocument ¶ 

func (client *Client) TrimDocument(request *TrimDocumentRequest) (response *TrimDocumentResponse, err error)

TrimDocument invokes the ocr.TrimDocument API synchronously

func (*Client) TrimDocumentWithCallback ¶ 

func (client *Client) TrimDocumentWithCallback(request *TrimDocumentRequest, callback func(response *TrimDocumentResponse, err error)) <-chan int

TrimDocumentWithCallback invokes the ocr.TrimDocument API asynchronously

func (*Client) TrimDocumentWithChan ¶ 

func (client *Client) TrimDocumentWithChan(request *TrimDocumentRequest) (<-chan *TrimDocumentResponse, <-chan error)

TrimDocumentWithChan invokes the ocr.TrimDocument API asynchronously

type Companies ¶ 

type Companies struct {
	Company []string `json:"Company" xml:"Company"`
}

Companies is a nested struct in ocr response

type Content ¶ 

type Content struct {
	PayeeRegisterNo  string   `json:"PayeeRegisterNo" xml:"PayeeRegisterNo"`
	PayerBankName    string   `json:"PayerBankName" xml:"PayerBankName"`
	PayeeAddress     string   `json:"PayeeAddress" xml:"PayeeAddress"`
	InvoiceNumber    string   `json:"InvoiceNumber" xml:"InvoiceNumber"`
	Clerk            string   `json:"Clerk" xml:"Clerk"`
	AntiFakeCode     string   `json:"AntiFakeCode" xml:"AntiFakeCode"`
	WithoutTaxAmount string   `json:"WithoutTaxAmount" xml:"WithoutTaxAmount"`
	InvoiceCode      string   `json:"InvoiceCode" xml:"InvoiceCode"`
	Payee            string   `json:"Payee" xml:"Payee"`
	SumAmount        string   `json:"SumAmount" xml:"SumAmount"`
	InvoiceAmount    string   `json:"InvoiceAmount" xml:"InvoiceAmount"`
	PayeeName        string   `json:"PayeeName" xml:"PayeeName"`
	TaxAmount        string   `json:"TaxAmount" xml:"TaxAmount"`
	PayeeBankName    string   `json:"PayeeBankName" xml:"PayeeBankName"`
	PayerAddress     string   `json:"PayerAddress" xml:"PayerAddress"`
	InvoiceDetails   string   `json:"InvoiceDetails" xml:"InvoiceDetails"`
	InvoiceNo        string   `json:"InvoiceNo" xml:"InvoiceNo"`
	InvoiceDate      string   `json:"InvoiceDate" xml:"InvoiceDate"`
	PayerName        string   `json:"PayerName" xml:"PayerName"`
	PayerRegisterNo  string   `json:"PayerRegisterNo" xml:"PayerRegisterNo"`
	Checker          string   `json:"Checker" xml:"Checker"`
	ItemName         []string `json:"ItemName" xml:"ItemName"`
}

Content is a nested struct in ocr response

type Data ¶ 

type Data struct {
	ExpiryDate          string               `json:"ExpiryDate" xml:"ExpiryDate"`
	Date                string               `json:"Date" xml:"Date"`
	ExpiryDay           string               `json:"ExpiryDay" xml:"ExpiryDay"`
	Seat                string               `json:"Seat" xml:"Seat"`
	EstablishDate       string               `json:"EstablishDate" xml:"EstablishDate"`
	FileContent         string               `json:"FileContent" xml:"FileContent"`
	ValidPeriod         string               `json:"ValidPeriod" xml:"ValidPeriod"`
	Type                string               `json:"Type" xml:"Type"`
	NameChineseRaw      string               `json:"NameChineseRaw" xml:"NameChineseRaw"`
	NativePlace         string               `json:"NativePlace" xml:"NativePlace"`
	LegalPerson         string               `json:"LegalPerson" xml:"LegalPerson"`
	RegisterNumber      string               `json:"RegisterNumber" xml:"RegisterNumber"`
	IssuePlaceRaw       string               `json:"IssuePlaceRaw" xml:"IssuePlaceRaw"`
	Price               float64              `json:"Price" xml:"Price"`
	Destination         string               `json:"Destination" xml:"Destination"`
	Relation            string               `json:"Relation" xml:"Relation"`
	Height              int64                `json:"Height" xml:"Height"`
	BirthPlaceRaw       string               `json:"BirthPlaceRaw" xml:"BirthPlaceRaw"`
	DepartureStation    string               `json:"DepartureStation" xml:"DepartureStation"`
	Gender              string               `json:"Gender" xml:"Gender"`
	BirthDay            string               `json:"BirthDay" xml:"BirthDay"`
	Success             bool                 `json:"Success" xml:"Success"`
	PassportNo          string               `json:"PassportNo" xml:"PassportNo"`
	IssueDate           string               `json:"IssueDate" xml:"IssueDate"`
	Status              string               `json:"Status" xml:"Status"`
	Name                string               `json:"Name" xml:"Name"`
	BankName            string               `json:"BankName" xml:"BankName"`
	IDNumber            string               `json:"IDNumber" xml:"IDNumber"`
	ErrorMessage        string               `json:"ErrorMessage" xml:"ErrorMessage"`
	Sex                 string               `json:"Sex" xml:"Sex"`
	Capital             string               `json:"Capital" xml:"Capital"`
	LineOne             string               `json:"LineOne" xml:"LineOne"`
	IsBlur              bool                 `json:"IsBlur" xml:"IsBlur"`
	Authority           string               `json:"Authority" xml:"Authority"`
	CardNumber          string               `json:"CardNumber" xml:"CardNumber"`
	VinCode             string               `json:"VinCode" xml:"VinCode"`
	ErrorCode           string               `json:"ErrorCode" xml:"ErrorCode"`
	Angle               float64              `json:"Angle" xml:"Angle"`
	Business            string               `json:"Business" xml:"Business"`
	Country             string               `json:"Country" xml:"Country"`
	JobId               string               `json:"JobId" xml:"JobId"`
	BirthPlace          string               `json:"BirthPlace" xml:"BirthPlace"`
	Result              string               `json:"Result" xml:"Result"`
	Nationality         string               `json:"Nationality" xml:"Nationality"`
	ValidDate           string               `json:"ValidDate" xml:"ValidDate"`
	Level               string               `json:"Level" xml:"Level"`
	PersonId            string               `json:"PersonId" xml:"PersonId"`
	SourceCountry       string               `json:"SourceCountry" xml:"SourceCountry"`
	NameChinese         string               `json:"NameChinese" xml:"NameChinese"`
	Address             string               `json:"Address" xml:"Address"`
	IsCard              bool                 `json:"IsCard" xml:"IsCard"`
	Number              string               `json:"Number" xml:"Number"`
	InputFile           string               `json:"InputFile" xml:"InputFile"`
	Width               int64                `json:"Width" xml:"Width"`
	BirthDate           string               `json:"BirthDate" xml:"BirthDate"`
	LineZero            string               `json:"LineZero" xml:"LineZero"`
	IssuePlace          string               `json:"IssuePlace" xml:"IssuePlace"`
	Departments         []string             `json:"Departments" xml:"Departments"`
	Companies           []string             `json:"Companies" xml:"Companies"`
	Emails              []string             `json:"Emails" xml:"Emails"`
	CellPhoneNumbers    []string             `json:"CellPhoneNumbers" xml:"CellPhoneNumbers"`
	OfficePhoneNumbers  []string             `json:"OfficePhoneNumbers" xml:"OfficePhoneNumbers"`
	Titles              []string             `json:"Titles" xml:"Titles"`
	Addresses           []string             `json:"Addresses" xml:"Addresses"`
	BackResult          BackResult           `json:"BackResult" xml:"BackResult"`
	SpoofResult         SpoofResult          `json:"SpoofResult" xml:"SpoofResult"`
	FaceResult          FaceResult           `json:"FaceResult" xml:"FaceResult"`
	Summary             Summary              `json:"Summary" xml:"Summary"`
	Box                 Box                  `json:"Box" xml:"Box"`
	Content             Content              `json:"Content" xml:"Content"`
	TitleArea           TitleArea            `json:"TitleArea" xml:"TitleArea"`
	Stamp               Stamp                `json:"Stamp" xml:"Stamp"`
	Emblem              Emblem               `json:"Emblem" xml:"Emblem"`
	FrontResult         FrontResult          `json:"FrontResult" xml:"FrontResult"`
	Title               Title                `json:"Title" xml:"Title"`
	QRCode              QRCode               `json:"QRCode" xml:"QRCode"`
	Elements            []Element            `json:"Elements" xml:"Elements"`
	Frames              []Frame              `json:"Frames" xml:"Frames"`
	InvalidStampAreas   []InvalidStampArea   `json:"InvalidStampAreas" xml:"InvalidStampAreas"`
	Regions             []Region             `json:"Regions" xml:"Regions"`
	Invoices            []Invoice            `json:"Invoices" xml:"Invoices"`
	Results             []Result             `json:"Results" xml:"Results"`
	UndertakeStampAreas []UndertakeStampArea `json:"UndertakeStampAreas" xml:"UndertakeStampAreas"`
	RegisterStampAreas  []RegisterStampArea  `json:"RegisterStampAreas" xml:"RegisterStampAreas"`
	OtherStampAreas     []OtherStampArea     `json:"OtherStampAreas" xml:"OtherStampAreas"`
	Plates              []Plate              `json:"Plates" xml:"Plates"`
	Signboards          []SignboardsItem     `json:"Signboards" xml:"Signboards"`
	Tables              []Table              `json:"Tables" xml:"Tables"`
}

Data is a nested struct in ocr response

type DataInRecognizeIndonesiaIdentityCard ¶ 

type DataInRecognizeIndonesiaIdentityCard struct {
	AddressFirstLine  AddressFirstLine  `json:"AddressFirstLine" xml:"AddressFirstLine"`
	AddressSecondLine AddressSecondLine `json:"AddressSecondLine" xml:"AddressSecondLine"`
	AddressThirdLine  AddressThirdLine  `json:"AddressThirdLine" xml:"AddressThirdLine"`
	AddressFourthLine AddressFourthLine `json:"AddressFourthLine" xml:"AddressFourthLine"`
	AddressFifthLine  AddressFifthLine  `json:"AddressFifthLine" xml:"AddressFifthLine"`
	BirthDate         BirthDate         `json:"BirthDate" xml:"BirthDate"`
	BirthPlace        BirthPlace        `json:"BirthPlace" xml:"BirthPlace"`
	CardBox           CardBox           `json:"CardBox" xml:"CardBox"`
	ExpiryDate        ExpiryDate        `json:"ExpiryDate" xml:"ExpiryDate"`
	Gender            Gender            `json:"Gender" xml:"Gender"`
	Height            Height            `json:"Height" xml:"Height"`
	IdNumber          IdNumber          `json:"IdNumber" xml:"IdNumber"`
	LicenseNumber     LicenseNumber     `json:"LicenseNumber" xml:"LicenseNumber"`
	MaritalStatus     MaritalStatus     `json:"MaritalStatus" xml:"MaritalStatus"`
	NameFirstLine     NameFirstLine     `json:"NameFirstLine" xml:"NameFirstLine"`
	NameSecondLine    NameSecondLine    `json:"NameSecondLine" xml:"NameSecondLine"`
	Nationality       Nationality       `json:"Nationality" xml:"Nationality"`
	Occupation        Occupation        `json:"Occupation" xml:"Occupation"`
	PortraitBox       PortraitBox       `json:"PortraitBox" xml:"PortraitBox"`
	Province          Province          `json:"Province" xml:"Province"`
	Religion          Religion          `json:"Religion" xml:"Religion"`
	Sex               Sex               `json:"Sex" xml:"Sex"`
}

DataInRecognizeIndonesiaIdentityCard is a nested struct in ocr response

type DataInRecognizeMalaysiaIdentityCard ¶ 

type DataInRecognizeMalaysiaIdentityCard struct {
	AddressFirstLine  AddressFirstLine  `json:"AddressFirstLine" xml:"AddressFirstLine"`
	AddressSecondLine AddressSecondLine `json:"AddressSecondLine" xml:"AddressSecondLine"`
	AddressThirdLine  AddressThirdLine  `json:"AddressThirdLine" xml:"AddressThirdLine"`
	AddressFourthLine AddressFourthLine `json:"AddressFourthLine" xml:"AddressFourthLine"`
	AddressFifthLine  AddressFifthLine  `json:"AddressFifthLine" xml:"AddressFifthLine"`
	CardBox           CardBox           `json:"CardBox" xml:"CardBox"`
	DriveClass        DriveClass        `json:"DriveClass" xml:"DriveClass"`
	ExpiryDate        ExpiryDate        `json:"ExpiryDate" xml:"ExpiryDate"`
	IdNumber          IdNumber          `json:"IdNumber" xml:"IdNumber"`
	IssueDate         IssueDate         `json:"IssueDate" xml:"IssueDate"`
	NameFirstLine     NameFirstLine     `json:"NameFirstLine" xml:"NameFirstLine"`
	NameSecondLine    NameSecondLine    `json:"NameSecondLine" xml:"NameSecondLine"`
	Nationality       Nationality       `json:"Nationality" xml:"Nationality"`
	PortraitBox       PortraitBox       `json:"PortraitBox" xml:"PortraitBox"`
	Sex               Sex               `json:"Sex" xml:"Sex"`
}

DataInRecognizeMalaysiaIdentityCard is a nested struct in ocr response

type DataInRecognizePdf ¶ 

type DataInRecognizePdf struct {
	Height    int64       `json:"Height" xml:"Height"`
	Width     int64       `json:"Width" xml:"Width"`
	OrgHeight int64       `json:"OrgHeight" xml:"OrgHeight"`
	OrgWidth  int64       `json:"OrgWidth" xml:"OrgWidth"`
	PageIndex int64       `json:"PageIndex" xml:"PageIndex"`
	Angle     int64       `json:"Angle" xml:"Angle"`
	WordsInfo []WordsInfo `json:"WordsInfo" xml:"WordsInfo"`
}

DataInRecognizePdf is a nested struct in ocr response

type DataInRecognizeQuotaInvoice ¶ 

type DataInRecognizeQuotaInvoice struct {
	Angle         int64           `json:"Angle" xml:"Angle"`
	Height        int64           `json:"Height" xml:"Height"`
	Width         int64           `json:"Width" xml:"Width"`
	OrgHeight     int64           `json:"OrgHeight" xml:"OrgHeight"`
	OrgWidth      int64           `json:"OrgWidth" xml:"OrgWidth"`
	Content       Content         `json:"Content" xml:"Content"`
	KeyValueInfos []KeyValueInfos `json:"KeyValueInfos" xml:"KeyValueInfos"`
}

DataInRecognizeQuotaInvoice is a nested struct in ocr response

type DataInRecognizeRussiaIdentityCard ¶ 

type DataInRecognizeRussiaIdentityCard struct {
	BirthDate            BirthDateInRecognizeRussiaIdentityCard `json:"BirthDate" xml:"BirthDate"`
	BirthPlaceFirstLine  BirthPlaceFirstLine                    `json:"BirthPlaceFirstLine" xml:"BirthPlaceFirstLine"`
	BirthPlaceSecondLine BirthPlaceSecondLine                   `json:"BirthPlaceSecondLine" xml:"BirthPlaceSecondLine"`
	BirthPlaceThirdLine  BirthPlaceThirdLine                    `json:"BirthPlaceThirdLine" xml:"BirthPlaceThirdLine"`
	CardBox              CardBox                                `json:"CardBox" xml:"CardBox"`
	GivenName            GivenName                              `json:"GivenName" xml:"GivenName"`
	IdNumber             IdNumber                               `json:"IdNumber" xml:"IdNumber"`
	PaternalName         PaternalName                           `json:"PaternalName" xml:"PaternalName"`
	PortraitBox          PortraitBox                            `json:"PortraitBox" xml:"PortraitBox"`
	Sex                  Sex                                    `json:"Sex" xml:"Sex"`
	SurnameFirstLine     SurnameFirstLine                       `json:"SurnameFirstLine" xml:"SurnameFirstLine"`
	SurnameSecondLine    SurnameSecondLine                      `json:"SurnameSecondLine" xml:"SurnameSecondLine"`
}

DataInRecognizeRussiaIdentityCard is a nested struct in ocr response

type DataInRecognizeStamp ¶ 

type DataInRecognizeStamp struct {
	Results []ResultsItem `json:"Results" xml:"Results"`
}

DataInRecognizeStamp is a nested struct in ocr response

type DataInRecognizeTicketInvoice ¶ 

type DataInRecognizeTicketInvoice struct {
	Count     int64     `json:"Count" xml:"Count"`
	Height    int64     `json:"Height" xml:"Height"`
	Width     int64     `json:"Width" xml:"Width"`
	OrgHeight int64     `json:"OrgHeight" xml:"OrgHeight"`
	OrgWidth  int64     `json:"OrgWidth" xml:"OrgWidth"`
	Results   []Results `json:"Results" xml:"Results"`
}

DataInRecognizeTicketInvoice is a nested struct in ocr response

type DataInRecognizeTurkeyIdentityCard ¶ 

type DataInRecognizeTurkeyIdentityCard struct {
	AuxiliaryTools        AuxiliaryTools                             `json:"AuxiliaryTools" xml:"AuxiliaryTools"`
	BirthDate             BirthDateInRecognizeTurkeyIdentityCard     `json:"BirthDate" xml:"BirthDate"`
	BirthPlace            BirthPlaceInRecognizeTurkeyIdentityCard    `json:"BirthPlace" xml:"BirthPlace"`
	BloodType             BloodType                                  `json:"BloodType" xml:"BloodType"`
	CardBox               CardBoxInRecognizeTurkeyIdentityCard       `json:"CardBox" xml:"CardBox"`
	Cilt                  Cilt                                       `json:"Cilt" xml:"Cilt"`
	DocumentNumber        DocumentNumber                             `json:"DocumentNumber" xml:"DocumentNumber"`
	DriveClass            DriveClassInRecognizeTurkeyIdentityCard    `json:"DriveClass" xml:"DriveClass"`
	DueDate               DueDate                                    `json:"DueDate" xml:"DueDate"`
	Duzenleyen            Duzenleyen                                 `json:"Duzenleyen" xml:"Duzenleyen"`
	EntryNumber           EntryNumber                                `json:"EntryNumber" xml:"EntryNumber"`
	ExpiryDate            ExpiryDateInRecognizeTurkeyIdentityCard    `json:"ExpiryDate" xml:"ExpiryDate"`
	FatherName            FatherName                                 `json:"FatherName" xml:"FatherName"`
	ForeignersId          ForeignersId                               `json:"ForeignersId" xml:"ForeignersId"`
	Gender                GenderInRecognizeTurkeyIdentityCard        `json:"Gender" xml:"Gender"`
	GivenName             GivenNameInRecognizeTurkeyIdentityCard     `json:"GivenName" xml:"GivenName"`
	IdNumber              IdNumberInRecognizeTurkeyIdentityCard      `json:"IdNumber" xml:"IdNumber"`
	IssueBy               IssueBy                                    `json:"IssueBy" xml:"IssueBy"`
	IssueCounty           IssueCounty                                `json:"IssueCounty" xml:"IssueCounty"`
	IssueDate             IssueDateInRecognizeTurkeyIdentityCard     `json:"IssueDate" xml:"IssueDate"`
	IssuePlace            IssuePlace                                 `json:"IssuePlace" xml:"IssuePlace"`
	Kutuk                 Kutuk                                      `json:"Kutuk" xml:"Kutuk"`
	LicenseNumber         LicenseNumberInRecognizeTurkeyIdentityCard `json:"LicenseNumber" xml:"LicenseNumber"`
	MaritalStatus         MaritalStatusInRecognizeTurkeyIdentityCard `json:"MaritalStatus" xml:"MaritalStatus"`
	MotherName            MotherName                                 `json:"MotherName" xml:"MotherName"`
	Name                  Name                                       `json:"Name" xml:"Name"`
	Nationality           NationalityInRecognizeTurkeyIdentityCard   `json:"Nationality" xml:"Nationality"`
	NeighborhoodVillage   NeighborhoodVillage                        `json:"NeighborhoodVillage" xml:"NeighborhoodVillage"`
	PageNumber            PageNumber                                 `json:"PageNumber" xml:"PageNumber"`
	PassportNumber        PassportNumber                             `json:"PassportNumber" xml:"PassportNumber"`
	PortraitBox           PortraitBoxInRecognizeTurkeyIdentityCard   `json:"PortraitBox" xml:"PortraitBox"`
	Province              ProvinceInRecognizeTurkeyIdentityCard      `json:"Province" xml:"Province"`
	ProvinceOfResidence   ProvinceOfResidence                        `json:"ProvinceOfResidence" xml:"ProvinceOfResidence"`
	ReasonOfIssue         ReasonOfIssue                              `json:"ReasonOfIssue" xml:"ReasonOfIssue"`
	RegisterNumber        RegisterNumber                             `json:"RegisterNumber" xml:"RegisterNumber"`
	Religion              ReligionInRecognizeTurkeyIdentityCard      `json:"Religion" xml:"Religion"`
	Sayfa                 Sayfa                                      `json:"Sayfa" xml:"Sayfa"`
	Seri                  Seri                                       `json:"Seri" xml:"Seri"`
	Surname               Surname                                    `json:"Surname" xml:"Surname"`
	TypeOfResidencePermit TypeOfResidencePermit                      `json:"TypeOfResidencePermit" xml:"TypeOfResidencePermit"`
	ValidUntil            ValidUntil                                 `json:"ValidUntil" xml:"ValidUntil"`
	Village               Village                                    `json:"Village" xml:"Village"`
	VolumeNumber          VolumeNumber                               `json:"VolumeNumber" xml:"VolumeNumber"`
	Sex                   SexInRecognizeTurkeyIdentityCard           `json:"Sex" xml:"Sex"`
}

DataInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type DataInRecognizeUkraineIdentityCard ¶ 

type DataInRecognizeUkraineIdentityCard struct {
	BirthDate      BirthDateInRecognizeUkraineIdentityCard   `json:"BirthDate" xml:"BirthDate"`
	CardBox        CardBoxInRecognizeUkraineIdentityCard     `json:"CardBox" xml:"CardBox"`
	DocumentNumber DocumentNumber                            `json:"DocumentNumber" xml:"DocumentNumber"`
	ExpiryDate     ExpiryDateInRecognizeUkraineIdentityCard  `json:"ExpiryDate" xml:"ExpiryDate"`
	NameEnglish    NameEnglish                               `json:"NameEnglish" xml:"NameEnglish"`
	NameUkraine    NameUkraine                               `json:"NameUkraine" xml:"NameUkraine"`
	Nationality    NationalityInRecognizeUkraineIdentityCard `json:"Nationality" xml:"Nationality"`
	Patronymic     Patronymic                                `json:"Patronymic" xml:"Patronymic"`
	PortraitBox    PortraitBoxInRecognizeUkraineIdentityCard `json:"PortraitBox" xml:"PortraitBox"`
	RecordNumber   RecordNumber                              `json:"RecordNumber" xml:"RecordNumber"`
	Sex            SexInRecognizeUkraineIdentityCard         `json:"Sex" xml:"Sex"`
	SurnameEnglish SurnameEnglish                            `json:"SurnameEnglish" xml:"SurnameEnglish"`
	SurnameUkraine SurnameUkraine                            `json:"SurnameUkraine" xml:"SurnameUkraine"`
}

DataInRecognizeUkraineIdentityCard is a nested struct in ocr response

type DataInRecognizeVerificationcode ¶ 

type DataInRecognizeVerificationcode struct {
	Content string `json:"Content" xml:"Content"`
}

DataInRecognizeVerificationcode is a nested struct in ocr response

type DataInRecognizeVietnamIdentityCard ¶ 

type DataInRecognizeVietnamIdentityCard struct {
	AddressFirstLine         AddressFirstLine                        `json:"AddressFirstLine" xml:"AddressFirstLine"`
	AddressSecondLine        AddressSecondLine                       `json:"AddressSecondLine" xml:"AddressSecondLine"`
	BirthDate                BirthDateInRecognizeVietnamIdentityCard `json:"BirthDate" xml:"BirthDate"`
	CardBox                  CardBox                                 `json:"CardBox" xml:"CardBox"`
	DriveClass               DriveClass                              `json:"DriveClass" xml:"DriveClass"`
	ExpiryDate               ExpiryDate                              `json:"ExpiryDate" xml:"ExpiryDate"`
	FullName                 FullName                                `json:"FullName" xml:"FullName"`
	IdNumber                 IdNumber                                `json:"IdNumber" xml:"IdNumber"`
	Nationality              Nationality                             `json:"Nationality" xml:"Nationality"`
	OriginPlaceFirstLine     OriginPlaceFirstLine                    `json:"OriginPlaceFirstLine" xml:"OriginPlaceFirstLine"`
	OriginPlaceSecondLine    OriginPlaceSecondLine                   `json:"OriginPlaceSecondLine" xml:"OriginPlaceSecondLine"`
	PortraitBox              PortraitBox                             `json:"PortraitBox" xml:"PortraitBox"`
	ResidencePlaceFirstLine  ResidencePlaceFirstLine                 `json:"ResidencePlaceFirstLine" xml:"ResidencePlaceFirstLine"`
	ResidencePlaceSecondLine ResidencePlaceSecondLine                `json:"ResidencePlaceSecondLine" xml:"ResidencePlaceSecondLine"`
	Sex                      Sex                                     `json:"Sex" xml:"Sex"`
}

DataInRecognizeVietnamIdentityCard is a nested struct in ocr response

type DataInTrimDocument ¶ 

type DataInTrimDocument struct {
	Content string `json:"Content" xml:"Content"`
}

DataInTrimDocument is a nested struct in ocr response

type Departments ¶ 

type Departments struct {
	Department []string `json:"Department" xml:"Department"`
}

Departments is a nested struct in ocr response

type DetectCardScreenshotRequest ¶ 

type DetectCardScreenshotRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

DetectCardScreenshotRequest is the request struct for api DetectCardScreenshot

func CreateDetectCardScreenshotRequest ¶ 

func CreateDetectCardScreenshotRequest() (request *DetectCardScreenshotRequest)

CreateDetectCardScreenshotRequest creates a request to invoke DetectCardScreenshot API

type DetectCardScreenshotResponse ¶ 

type DetectCardScreenshotResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

DetectCardScreenshotResponse is the response struct for api DetectCardScreenshot

func CreateDetectCardScreenshotResponse ¶ 

func CreateDetectCardScreenshotResponse() (response *DetectCardScreenshotResponse)

CreateDetectCardScreenshotResponse creates a response to parse from DetectCardScreenshot response

type DocumentNumber ¶ 

type DocumentNumber struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

DocumentNumber is a nested struct in ocr response

type DriveClass ¶ 

type DriveClass struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

DriveClass is a nested struct in ocr response

type DriveClassInRecognizeTurkeyIdentityCard ¶ 

type DriveClassInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

DriveClassInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type DueDate ¶ 

type DueDate struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

DueDate is a nested struct in ocr response

type Duzenleyen ¶ 

type Duzenleyen struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Duzenleyen is a nested struct in ocr response

type Element ¶ 

type Element struct {
	Name           string          `json:"Name" xml:"Name"`
	Value          string          `json:"Value" xml:"Value"`
	TaskId         string          `json:"TaskId" xml:"TaskId"`
	Text           string          `json:"Text" xml:"Text"`
	Score          float64         `json:"Score" xml:"Score"`
	ImageURL       string          `json:"ImageURL" xml:"ImageURL"`
	Boxes          []int           `json:"Boxes" xml:"Boxes"`
	TextRectangles []TextRectangle `json:"TextRectangles" xml:"TextRectangles"`
	Results        []Result        `json:"Results" xml:"Results"`
}

Element is a nested struct in ocr response

type ElementsInRecognizeQrCode ¶ 

type ElementsInRecognizeQrCode struct {
	Element []Element `json:"Element" xml:"Element"`
}

ElementsInRecognizeQrCode is a nested struct in ocr response

type ElementsInRecognizeTakeoutOrder ¶ 

type ElementsInRecognizeTakeoutOrder struct {
	Element []Element `json:"Element" xml:"Element"`
}

ElementsInRecognizeTakeoutOrder is a nested struct in ocr response

type ElementsInRecognizeVideoCharacter ¶ 

type ElementsInRecognizeVideoCharacter struct {
	Element []Element `json:"Element" xml:"Element"`
}

ElementsInRecognizeVideoCharacter is a nested struct in ocr response

type Emails ¶ 

type Emails struct {
	Email []string `json:"Email" xml:"Email"`
}

Emails is a nested struct in ocr response

type Emblem ¶ 

type Emblem struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

Emblem is a nested struct in ocr response

type EntryNumber ¶ 

type EntryNumber struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

EntryNumber is a nested struct in ocr response

type ExpiryDate ¶ 

type ExpiryDate struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ExpiryDate is a nested struct in ocr response

type ExpiryDateInRecognizeTurkeyIdentityCard ¶ 

type ExpiryDateInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ExpiryDateInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type ExpiryDateInRecognizeUkraineIdentityCard ¶ 

type ExpiryDateInRecognizeUkraineIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ExpiryDateInRecognizeUkraineIdentityCard is a nested struct in ocr response

type FaceRectVertice ¶ 

type FaceRectVertice struct {
	Y float64 `json:"Y" xml:"Y"`
	X float64 `json:"X" xml:"X"`
}

FaceRectVertice is a nested struct in ocr response

type FaceRectVertices ¶ 

type FaceRectVertices struct {
	FaceRectVertice []FaceRectVertice `json:"FaceRectVertice" xml:"FaceRectVertice"`
}

FaceRectVertices is a nested struct in ocr response

type FaceRectangle ¶ 

type FaceRectangle struct {
	Angle  float64 `json:"Angle" xml:"Angle"`
	Size   Size    `json:"Size" xml:"Size"`
	Center Center  `json:"Center" xml:"Center"`
}

FaceRectangle is a nested struct in ocr response

type FaceResult ¶ 

type FaceResult struct {
	Name          string `json:"Name" xml:"Name"`
	EndDate       string `json:"EndDate" xml:"EndDate"`
	IssueUnit     string `json:"IssueUnit" xml:"IssueUnit"`
	EngineNumber  string `json:"EngineNumber" xml:"EngineNumber"`
	VehicleType   string `json:"VehicleType" xml:"VehicleType"`
	PlateNumber   string `json:"PlateNumber" xml:"PlateNumber"`
	Owner         string `json:"Owner" xml:"Owner"`
	Vin           string `json:"Vin" xml:"Vin"`
	UseCharacter  string `json:"UseCharacter" xml:"UseCharacter"`
	Address       string `json:"Address" xml:"Address"`
	StartDate     string `json:"StartDate" xml:"StartDate"`
	Gender        string `json:"Gender" xml:"Gender"`
	LicenseNumber string `json:"LicenseNumber" xml:"LicenseNumber"`
	Model         string `json:"Model" xml:"Model"`
	RegisterDate  string `json:"RegisterDate" xml:"RegisterDate"`
	IssueDate     string `json:"IssueDate" xml:"IssueDate"`
}

FaceResult is a nested struct in ocr response

type FatherName ¶ 

type FatherName struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

FatherName is a nested struct in ocr response

type ForeignersId ¶ 

type ForeignersId struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ForeignersId is a nested struct in ocr response

type Frame ¶ 

type Frame struct {
	Timestamp int64     `json:"Timestamp" xml:"Timestamp"`
	Elements  []Element `json:"Elements" xml:"Elements"`
}

Frame is a nested struct in ocr response

type Frames ¶ 

type Frames struct {
	Frame []Frame `json:"Frame" xml:"Frame"`
}

Frames is a nested struct in ocr response

type FrontResult ¶ 

type FrontResult struct {
	BirthDate        string            `json:"BirthDate" xml:"BirthDate"`
	Gender           string            `json:"Gender" xml:"Gender"`
	Address          string            `json:"Address" xml:"Address"`
	Nationality      string            `json:"Nationality" xml:"Nationality"`
	Name             string            `json:"Name" xml:"Name"`
	IDNumber         string            `json:"IDNumber" xml:"IDNumber"`
	FaceRectangle    FaceRectangle     `json:"FaceRectangle" xml:"FaceRectangle"`
	FaceRectVertices []FaceRectVertice `json:"FaceRectVertices" xml:"FaceRectVertices"`
	CardAreas        []CardArea        `json:"CardAreas" xml:"CardAreas"`
}

FrontResult is a nested struct in ocr response

type FullName ¶ 

type FullName struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

FullName is a nested struct in ocr response

type Gender ¶ 

type Gender struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Gender is a nested struct in ocr response

type GenderInRecognizeTurkeyIdentityCard ¶ 

type GenderInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

GenderInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type GeneralText ¶ 

type GeneralText struct {
	GeneralTextItem []GeneralTextItem `json:"GeneralText" xml:"GeneralText"`
}

GeneralText is a nested struct in ocr response

type GeneralTextItem ¶ 

type GeneralTextItem struct {
	Confidence float64 `json:"Confidence" xml:"Confidence"`
	Content    string  `json:"Content" xml:"Content"`
}

GeneralTextItem is a nested struct in ocr response

type GetAsyncJobResultRequest ¶ 

type GetAsyncJobResultRequest struct {
	*requests.RpcRequest
	JobId string           `position:"Body" name:"JobId"`
	Async requests.Boolean `position:"Body" name:"Async"`
}

GetAsyncJobResultRequest is the request struct for api GetAsyncJobResult

func CreateGetAsyncJobResultRequest ¶ 

func CreateGetAsyncJobResultRequest() (request *GetAsyncJobResultRequest)

CreateGetAsyncJobResultRequest creates a request to invoke GetAsyncJobResult API

type GetAsyncJobResultResponse ¶ 

type GetAsyncJobResultResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetAsyncJobResultResponse is the response struct for api GetAsyncJobResult

func CreateGetAsyncJobResultResponse ¶ 

func CreateGetAsyncJobResultResponse() (response *GetAsyncJobResultResponse)

CreateGetAsyncJobResultResponse creates a response to parse from GetAsyncJobResult response

type GivenName ¶ 

type GivenName struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

GivenName is a nested struct in ocr response

type GivenNameInRecognizeTurkeyIdentityCard ¶ 

type GivenNameInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

GivenNameInRecognizeTurkeyIdentityCard is a nested struct in ocr response 

type Head struct {
	Head []string `json:"Head" xml:"Head"`
}

Head is a nested struct in ocr response

type Height ¶ 

type Height struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Height is a nested struct in ocr response

type IdNumber ¶ 

type IdNumber struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

IdNumber is a nested struct in ocr response

type IdNumberInRecognizeTurkeyIdentityCard ¶ 

type IdNumberInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

IdNumberInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type InvalidStampArea ¶ 

type InvalidStampArea struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

InvalidStampArea is a nested struct in ocr response

type InvalidStampAreas ¶ 

type InvalidStampAreas struct {
	InvalidStampArea []InvalidStampArea `json:"InvalidStampArea" xml:"InvalidStampArea"`
}

InvalidStampAreas is a nested struct in ocr response

type Invoice ¶ 

type Invoice struct {
	RotateType int        `json:"RotateType" xml:"RotateType"`
	InvoiceRoi InvoiceRoi `json:"InvoiceRoi" xml:"InvoiceRoi"`
	Items      []Item     `json:"Items" xml:"Items"`
}

Invoice is a nested struct in ocr response

type InvoiceAmounts ¶ 

type InvoiceAmounts struct {
	InvoiceAmount []float64 `json:"InvoiceAmount" xml:"InvoiceAmount"`
}

InvoiceAmounts is a nested struct in ocr response

type InvoiceCodes ¶ 

type InvoiceCodes struct {
	InvoiceCode []float64 `json:"InvoiceCode" xml:"InvoiceCode"`
}

InvoiceCodes is a nested struct in ocr response

type InvoiceDates ¶ 

type InvoiceDates struct {
	InvoiceDate []float64 `json:"InvoiceDate" xml:"InvoiceDate"`
}

InvoiceDates is a nested struct in ocr response

type InvoiceFakeCodes ¶ 

type InvoiceFakeCodes struct {
	InvoiceFakeCode []float64 `json:"InvoiceFakeCode" xml:"InvoiceFakeCode"`
}

InvoiceFakeCodes is a nested struct in ocr response

type InvoiceNoes ¶ 

type InvoiceNoes struct {
	InvoiceNo []float64 `json:"InvoiceNo" xml:"InvoiceNo"`
}

InvoiceNoes is a nested struct in ocr response

type InvoiceRoi ¶ 

type InvoiceRoi struct {
	W float64 `json:"W" xml:"W"`
	H float64 `json:"H" xml:"H"`
	Y float64 `json:"Y" xml:"Y"`
	X float64 `json:"X" xml:"X"`
}

InvoiceRoi is a nested struct in ocr response

type Invoices ¶ 

type Invoices struct {
	Invoice []Invoice `json:"Invoice" xml:"Invoice"`
}

Invoices is a nested struct in ocr response

type IssueBy ¶ 

type IssueBy struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

IssueBy is a nested struct in ocr response

type IssueCounty ¶ 

type IssueCounty struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

IssueCounty is a nested struct in ocr response

type IssueDate ¶ 

type IssueDate struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

IssueDate is a nested struct in ocr response

type IssueDateInRecognizeTurkeyIdentityCard ¶ 

type IssueDateInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

IssueDateInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type IssuePlace ¶ 

type IssuePlace struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

IssuePlace is a nested struct in ocr response

type Item ¶ 

type Item struct {
	Text    string  `json:"Text" xml:"Text"`
	ItemRoi ItemRoi `json:"ItemRoi" xml:"ItemRoi"`
}

Item is a nested struct in ocr response

type ItemName ¶ 

type ItemName struct {
	ItemName []string `json:"ItemName" xml:"ItemName"`
}

ItemName is a nested struct in ocr response

type ItemNames ¶ 

type ItemNames struct {
	ItemNames []int `json:"ItemNames" xml:"ItemNames"`
}

ItemNames is a nested struct in ocr response

type ItemRoi ¶ 

type ItemRoi struct {
	Angle  float64 `json:"Angle" xml:"Angle"`
	Size   Size    `json:"Size" xml:"Size"`
	Center Center  `json:"Center" xml:"Center"`
}

ItemRoi is a nested struct in ocr response

type Items ¶ 

type Items struct {
	Item []Item `json:"Item" xml:"Item"`
}

Items is a nested struct in ocr response

type KeyPoints ¶ 

type KeyPoints struct {
	X float64 `json:"X" xml:"X"`
	Y float64 `json:"Y" xml:"Y"`
}

KeyPoints is a nested struct in ocr response

type KeyPointsInRecognizeIndonesiaIdentityCard ¶ 

type KeyPointsInRecognizeIndonesiaIdentityCard struct {
	KeyPoints []KeyPoints `json:"keyPoints" xml:"keyPoints"`
}

KeyPointsInRecognizeIndonesiaIdentityCard is a nested struct in ocr response

type KeyPointsInRecognizeMalaysiaIdentityCard ¶ 

type KeyPointsInRecognizeMalaysiaIdentityCard struct {
	KeyPoints []KeyPoints `json:"keyPoints" xml:"keyPoints"`
}

KeyPointsInRecognizeMalaysiaIdentityCard is a nested struct in ocr response

type KeyPointsInRecognizeRussiaIdentityCard ¶ 

type KeyPointsInRecognizeRussiaIdentityCard struct {
	KeyPoints []KeyPoints `json:"keyPoints" xml:"keyPoints"`
}

KeyPointsInRecognizeRussiaIdentityCard is a nested struct in ocr response

type KeyPointsInRecognizeTurkeyIdentityCard ¶ 

type KeyPointsInRecognizeTurkeyIdentityCard struct {
	KeyPoints []KeyPoints `json:"keyPoints" xml:"keyPoints"`
}

KeyPointsInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type KeyPointsInRecognizeUkraineIdentityCard ¶ 

type KeyPointsInRecognizeUkraineIdentityCard struct {
	KeyPoints []KeyPoints `json:"keyPoints" xml:"keyPoints"`
}

KeyPointsInRecognizeUkraineIdentityCard is a nested struct in ocr response

type KeyPointsInRecognizeVietnamIdentityCard ¶ 

type KeyPointsInRecognizeVietnamIdentityCard struct {
	KeyPoints []KeyPoints `json:"keyPoints" xml:"keyPoints"`
}

KeyPointsInRecognizeVietnamIdentityCard is a nested struct in ocr response

type KeyValueInfos ¶ 

type KeyValueInfos struct {
	Key            string           `json:"Key" xml:"Key"`
	Value          string           `json:"Value" xml:"Value"`
	ValueScore     float64          `json:"ValueScore" xml:"ValueScore"`
	ValuePositions []ValuePositions `json:"ValuePositions" xml:"ValuePositions"`
}

KeyValueInfos is a nested struct in ocr response

type KeyValueInfosInRecognizeQuotaInvoice ¶ 

type KeyValueInfosInRecognizeQuotaInvoice struct {
	KeyValueInfos []KeyValueInfos `json:"keyValueInfos" xml:"keyValueInfos"`
}

KeyValueInfosInRecognizeQuotaInvoice is a nested struct in ocr response

type KeyValueInfosInRecognizeTicketInvoice ¶ 

type KeyValueInfosInRecognizeTicketInvoice struct {
	KeyValueInfos []KeyValueInfos `json:"keyValueInfos" xml:"keyValueInfos"`
}

KeyValueInfosInRecognizeTicketInvoice is a nested struct in ocr response

type Kutuk ¶ 

type Kutuk struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Kutuk is a nested struct in ocr response

type LicenseNumber ¶ 

type LicenseNumber struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

LicenseNumber is a nested struct in ocr response

type LicenseNumberInRecognizeTurkeyIdentityCard ¶ 

type LicenseNumberInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

LicenseNumberInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type MaritalStatus ¶ 

type MaritalStatus struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

MaritalStatus is a nested struct in ocr response

type MaritalStatusInRecognizeTurkeyIdentityCard ¶ 

type MaritalStatusInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

MaritalStatusInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type MotherName ¶ 

type MotherName struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

MotherName is a nested struct in ocr response

type Name ¶ 

type Name struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Name is a nested struct in ocr response

type NameEnglish ¶ 

type NameEnglish struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

NameEnglish is a nested struct in ocr response

type NameFirstLine ¶ 

type NameFirstLine struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

NameFirstLine is a nested struct in ocr response

type NameSecondLine ¶ 

type NameSecondLine struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

NameSecondLine is a nested struct in ocr response

type NameUkraine ¶ 

type NameUkraine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

NameUkraine is a nested struct in ocr response

type Nationality ¶ 

type Nationality struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Nationality is a nested struct in ocr response

type NationalityInRecognizeTurkeyIdentityCard ¶ 

type NationalityInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

NationalityInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type NationalityInRecognizeUkraineIdentityCard ¶ 

type NationalityInRecognizeUkraineIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

NationalityInRecognizeUkraineIdentityCard is a nested struct in ocr response

type NeighborhoodVillage ¶ 

type NeighborhoodVillage struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

NeighborhoodVillage is a nested struct in ocr response

type Occupation ¶ 

type Occupation struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Occupation is a nested struct in ocr response

type OfficePhoneNumbers ¶ 

type OfficePhoneNumbers struct {
	OfficePhoneNumber []string `json:"OfficePhoneNumber" xml:"OfficePhoneNumber"`
}

OfficePhoneNumbers is a nested struct in ocr response

type OriginPlaceFirstLine ¶ 

type OriginPlaceFirstLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

OriginPlaceFirstLine is a nested struct in ocr response

type OriginPlaceSecondLine ¶ 

type OriginPlaceSecondLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

OriginPlaceSecondLine is a nested struct in ocr response

type OtherStampArea ¶ 

type OtherStampArea struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

OtherStampArea is a nested struct in ocr response

type OtherStampAreas ¶ 

type OtherStampAreas struct {
	OtherStampArea []OtherStampArea `json:"OtherStampArea" xml:"OtherStampArea"`
}

OtherStampAreas is a nested struct in ocr response

type PageNumber ¶ 

type PageNumber struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

PageNumber is a nested struct in ocr response

type PassportNumber ¶ 

type PassportNumber struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

PassportNumber is a nested struct in ocr response

type PaternalName ¶ 

type PaternalName struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

PaternalName is a nested struct in ocr response

type Patronymic ¶ 

type Patronymic struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Patronymic is a nested struct in ocr response

type PayeeAddresses ¶ 

type PayeeAddresses struct {
	PayeeAddress []float64 `json:"PayeeAddress" xml:"PayeeAddress"`
}

PayeeAddresses is a nested struct in ocr response

type PayeeBankNames ¶ 

type PayeeBankNames struct {
	PayeeBankName []float64 `json:"PayeeBankName" xml:"PayeeBankName"`
}

PayeeBankNames is a nested struct in ocr response

type PayeeNames ¶ 

type PayeeNames struct {
	PayeeName []float64 `json:"PayeeName" xml:"PayeeName"`
}

PayeeNames is a nested struct in ocr response

type PayeeRegisterNoes ¶ 

type PayeeRegisterNoes struct {
	PayeeRegisterNo []float64 `json:"PayeeRegisterNo" xml:"PayeeRegisterNo"`
}

PayeeRegisterNoes is a nested struct in ocr response

type Payees ¶ 

type Payees struct {
	Payee []float64 `json:"Payee" xml:"Payee"`
}

Payees is a nested struct in ocr response

type PayerAddresses ¶ 

type PayerAddresses struct {
	PayerAddress []float64 `json:"PayerAddress" xml:"PayerAddress"`
}

PayerAddresses is a nested struct in ocr response

type PayerBankNames ¶ 

type PayerBankNames struct {
	PayerBankNames []float64 `json:"PayerBankNames" xml:"PayerBankNames"`
}

PayerBankNames is a nested struct in ocr response

type PayerNames ¶ 

type PayerNames struct {
	PayerName []float64 `json:"PayerName" xml:"PayerName"`
}

PayerNames is a nested struct in ocr response

type PayerRegisterNoes ¶ 

type PayerRegisterNoes struct {
	PayerRegisterNo []float64 `json:"PayerRegisterNo" xml:"PayerRegisterNo"`
}

PayerRegisterNoes is a nested struct in ocr response

type Plate ¶ 

type Plate struct {
	PlateTypeConfidence float64     `json:"PlateTypeConfidence" xml:"PlateTypeConfidence"`
	PlateType           string      `json:"PlateType" xml:"PlateType"`
	Confidence          float64     `json:"Confidence" xml:"Confidence"`
	PlateNumber         string      `json:"PlateNumber" xml:"PlateNumber"`
	Roi                 Roi         `json:"Roi" xml:"Roi"`
	Positions           []Positions `json:"Positions" xml:"Positions"`
}

Plate is a nested struct in ocr response

type Plates ¶ 

type Plates struct {
	Plate []Plate `json:"Plate" xml:"Plate"`
}

Plates is a nested struct in ocr response

type Points ¶ 

type Points struct {
	Points []int `json:"Points" xml:"Points"`
}

Points is a nested struct in ocr response

type PortraitBox ¶ 

type PortraitBox struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

PortraitBox is a nested struct in ocr response

type PortraitBoxInRecognizeTurkeyIdentityCard ¶ 

type PortraitBoxInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

PortraitBoxInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type PortraitBoxInRecognizeUkraineIdentityCard ¶ 

type PortraitBoxInRecognizeUkraineIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

PortraitBoxInRecognizeUkraineIdentityCard is a nested struct in ocr response

type Positions ¶ 

type Positions struct {
	Y int64 `json:"Y" xml:"Y"`
	X int64 `json:"X" xml:"X"`
}

Positions is a nested struct in ocr response

type PositionsInRecognizeLicensePlate ¶ 

type PositionsInRecognizeLicensePlate struct {
	Positions []Positions `json:"positions" xml:"positions"`
}

PositionsInRecognizeLicensePlate is a nested struct in ocr response

type PositionsInRecognizePdf ¶ 

type PositionsInRecognizePdf struct {
	Positions []Positions `json:"positions" xml:"positions"`
}

PositionsInRecognizePdf is a nested struct in ocr response

type Province ¶ 

type Province struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Province is a nested struct in ocr response

type ProvinceInRecognizeTurkeyIdentityCard ¶ 

type ProvinceInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ProvinceInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type ProvinceOfResidence ¶ 

type ProvinceOfResidence struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ProvinceOfResidence is a nested struct in ocr response

type QRCode ¶ 

type QRCode struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

QRCode is a nested struct in ocr response

type QrCodesData ¶ 

type QrCodesData struct {
	QrCodeData []string `json:"QrCodeData" xml:"QrCodeData"`
}

QrCodesData is a nested struct in ocr response

type ReasonOfIssue ¶ 

type ReasonOfIssue struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ReasonOfIssue is a nested struct in ocr response

type RecognizeAccountPageRequest ¶ 

type RecognizeAccountPageRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeAccountPageRequest is the request struct for api RecognizeAccountPage

func CreateRecognizeAccountPageRequest ¶ 

func CreateRecognizeAccountPageRequest() (request *RecognizeAccountPageRequest)

CreateRecognizeAccountPageRequest creates a request to invoke RecognizeAccountPage API

type RecognizeAccountPageResponse ¶ 

type RecognizeAccountPageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeAccountPageResponse is the response struct for api RecognizeAccountPage

func CreateRecognizeAccountPageResponse ¶ 

func CreateRecognizeAccountPageResponse() (response *RecognizeAccountPageResponse)

CreateRecognizeAccountPageResponse creates a response to parse from RecognizeAccountPage response

type RecognizeBankCardRequest ¶ 

type RecognizeBankCardRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeBankCardRequest is the request struct for api RecognizeBankCard

func CreateRecognizeBankCardRequest ¶ 

func CreateRecognizeBankCardRequest() (request *RecognizeBankCardRequest)

CreateRecognizeBankCardRequest creates a request to invoke RecognizeBankCard API

type RecognizeBankCardResponse ¶ 

type RecognizeBankCardResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeBankCardResponse is the response struct for api RecognizeBankCard

func CreateRecognizeBankCardResponse ¶ 

func CreateRecognizeBankCardResponse() (response *RecognizeBankCardResponse)

CreateRecognizeBankCardResponse creates a response to parse from RecognizeBankCard response

type RecognizeBusinessCardRequest ¶ 

type RecognizeBusinessCardRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeBusinessCardRequest is the request struct for api RecognizeBusinessCard

func CreateRecognizeBusinessCardRequest ¶ 

func CreateRecognizeBusinessCardRequest() (request *RecognizeBusinessCardRequest)

CreateRecognizeBusinessCardRequest creates a request to invoke RecognizeBusinessCard API

type RecognizeBusinessCardResponse ¶ 

type RecognizeBusinessCardResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeBusinessCardResponse is the response struct for api RecognizeBusinessCard

func CreateRecognizeBusinessCardResponse ¶ 

func CreateRecognizeBusinessCardResponse() (response *RecognizeBusinessCardResponse)

CreateRecognizeBusinessCardResponse creates a response to parse from RecognizeBusinessCard response

type RecognizeBusinessLicenseRequest ¶ 

type RecognizeBusinessLicenseRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeBusinessLicenseRequest is the request struct for api RecognizeBusinessLicense

func CreateRecognizeBusinessLicenseRequest ¶ 

func CreateRecognizeBusinessLicenseRequest() (request *RecognizeBusinessLicenseRequest)

CreateRecognizeBusinessLicenseRequest creates a request to invoke RecognizeBusinessLicense API

type RecognizeBusinessLicenseResponse ¶ 

type RecognizeBusinessLicenseResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeBusinessLicenseResponse is the response struct for api RecognizeBusinessLicense

func CreateRecognizeBusinessLicenseResponse ¶ 

func CreateRecognizeBusinessLicenseResponse() (response *RecognizeBusinessLicenseResponse)

CreateRecognizeBusinessLicenseResponse creates a response to parse from RecognizeBusinessLicense response

type RecognizeCharacterRequest ¶ 

type RecognizeCharacterRequest struct {
	*requests.RpcRequest
	MinHeight         requests.Integer `position:"Body" name:"MinHeight"`
	ImageType         requests.Integer `position:"Body" name:"ImageType"`
	OutputProbability requests.Boolean `position:"Body" name:"OutputProbability"`
	ImageURL          string           `position:"Body" name:"ImageURL"`
}

RecognizeCharacterRequest is the request struct for api RecognizeCharacter

func CreateRecognizeCharacterRequest ¶ 

func CreateRecognizeCharacterRequest() (request *RecognizeCharacterRequest)

CreateRecognizeCharacterRequest creates a request to invoke RecognizeCharacter API

type RecognizeCharacterResponse ¶ 

type RecognizeCharacterResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeCharacterResponse is the response struct for api RecognizeCharacter

func CreateRecognizeCharacterResponse ¶ 

func CreateRecognizeCharacterResponse() (response *RecognizeCharacterResponse)

CreateRecognizeCharacterResponse creates a response to parse from RecognizeCharacter response

type RecognizeChinapassportRequest ¶ 

type RecognizeChinapassportRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RecognizeChinapassportRequest is the request struct for api RecognizeChinapassport

func CreateRecognizeChinapassportRequest ¶ 

func CreateRecognizeChinapassportRequest() (request *RecognizeChinapassportRequest)

CreateRecognizeChinapassportRequest creates a request to invoke RecognizeChinapassport API

type RecognizeChinapassportResponse ¶ 

type RecognizeChinapassportResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeChinapassportResponse is the response struct for api RecognizeChinapassport

func CreateRecognizeChinapassportResponse ¶ 

func CreateRecognizeChinapassportResponse() (response *RecognizeChinapassportResponse)

CreateRecognizeChinapassportResponse creates a response to parse from RecognizeChinapassport response

type RecognizeDriverLicenseRequest ¶ 

type RecognizeDriverLicenseRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	Side      string           `position:"Body" name:"Side"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeDriverLicenseRequest is the request struct for api RecognizeDriverLicense

func CreateRecognizeDriverLicenseRequest ¶ 

func CreateRecognizeDriverLicenseRequest() (request *RecognizeDriverLicenseRequest)

CreateRecognizeDriverLicenseRequest creates a request to invoke RecognizeDriverLicense API

type RecognizeDriverLicenseResponse ¶ 

type RecognizeDriverLicenseResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeDriverLicenseResponse is the response struct for api RecognizeDriverLicense

func CreateRecognizeDriverLicenseResponse ¶ 

func CreateRecognizeDriverLicenseResponse() (response *RecognizeDriverLicenseResponse)

CreateRecognizeDriverLicenseResponse creates a response to parse from RecognizeDriverLicense response

type RecognizeDrivingLicenseRequest ¶ 

type RecognizeDrivingLicenseRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	Side      string           `position:"Body" name:"Side"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeDrivingLicenseRequest is the request struct for api RecognizeDrivingLicense

func CreateRecognizeDrivingLicenseRequest ¶ 

func CreateRecognizeDrivingLicenseRequest() (request *RecognizeDrivingLicenseRequest)

CreateRecognizeDrivingLicenseRequest creates a request to invoke RecognizeDrivingLicense API

type RecognizeDrivingLicenseResponse ¶ 

type RecognizeDrivingLicenseResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeDrivingLicenseResponse is the response struct for api RecognizeDrivingLicense

func CreateRecognizeDrivingLicenseResponse ¶ 

func CreateRecognizeDrivingLicenseResponse() (response *RecognizeDrivingLicenseResponse)

CreateRecognizeDrivingLicenseResponse creates a response to parse from RecognizeDrivingLicense response

type RecognizeIdentityCardRequest ¶ 

type RecognizeIdentityCardRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	Side      string           `position:"Body" name:"Side"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeIdentityCardRequest is the request struct for api RecognizeIdentityCard

func CreateRecognizeIdentityCardRequest ¶ 

func CreateRecognizeIdentityCardRequest() (request *RecognizeIdentityCardRequest)

CreateRecognizeIdentityCardRequest creates a request to invoke RecognizeIdentityCard API

type RecognizeIdentityCardResponse ¶ 

type RecognizeIdentityCardResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeIdentityCardResponse is the response struct for api RecognizeIdentityCard

func CreateRecognizeIdentityCardResponse ¶ 

func CreateRecognizeIdentityCardResponse() (response *RecognizeIdentityCardResponse)

CreateRecognizeIdentityCardResponse creates a response to parse from RecognizeIdentityCard response

type RecognizeIndonesiaIdentityCardRequest ¶ 

type RecognizeIndonesiaIdentityCardRequest struct {
	*requests.RpcRequest
	ImageUrl string `position:"Body" name:"ImageUrl"`
}

RecognizeIndonesiaIdentityCardRequest is the request struct for api RecognizeIndonesiaIdentityCard

func CreateRecognizeIndonesiaIdentityCardRequest ¶ 

func CreateRecognizeIndonesiaIdentityCardRequest() (request *RecognizeIndonesiaIdentityCardRequest)

CreateRecognizeIndonesiaIdentityCardRequest creates a request to invoke RecognizeIndonesiaIdentityCard API

type RecognizeIndonesiaIdentityCardResponse ¶ 

type RecognizeIndonesiaIdentityCardResponse struct {
	*responses.BaseResponse
	RequestId string                               `json:"RequestId" xml:"RequestId"`
	Code      string                               `json:"Code" xml:"Code"`
	Message   string                               `json:"Message" xml:"Message"`
	Data      DataInRecognizeIndonesiaIdentityCard `json:"Data" xml:"Data"`
}

RecognizeIndonesiaIdentityCardResponse is the response struct for api RecognizeIndonesiaIdentityCard

func CreateRecognizeIndonesiaIdentityCardResponse ¶ 

func CreateRecognizeIndonesiaIdentityCardResponse() (response *RecognizeIndonesiaIdentityCardResponse)

CreateRecognizeIndonesiaIdentityCardResponse creates a response to parse from RecognizeIndonesiaIdentityCard response

type RecognizeLicensePlateRequest ¶ 

type RecognizeLicensePlateRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeLicensePlateRequest is the request struct for api RecognizeLicensePlate

func CreateRecognizeLicensePlateRequest ¶ 

func CreateRecognizeLicensePlateRequest() (request *RecognizeLicensePlateRequest)

CreateRecognizeLicensePlateRequest creates a request to invoke RecognizeLicensePlate API

type RecognizeLicensePlateResponse ¶ 

type RecognizeLicensePlateResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeLicensePlateResponse is the response struct for api RecognizeLicensePlate

func CreateRecognizeLicensePlateResponse ¶ 

func CreateRecognizeLicensePlateResponse() (response *RecognizeLicensePlateResponse)

CreateRecognizeLicensePlateResponse creates a response to parse from RecognizeLicensePlate response

type RecognizeMalaysiaIdentityCardRequest ¶ 

type RecognizeMalaysiaIdentityCardRequest struct {
	*requests.RpcRequest
	ImageUrl string `position:"Body" name:"ImageUrl"`
}

RecognizeMalaysiaIdentityCardRequest is the request struct for api RecognizeMalaysiaIdentityCard

func CreateRecognizeMalaysiaIdentityCardRequest ¶ 

func CreateRecognizeMalaysiaIdentityCardRequest() (request *RecognizeMalaysiaIdentityCardRequest)

CreateRecognizeMalaysiaIdentityCardRequest creates a request to invoke RecognizeMalaysiaIdentityCard API

type RecognizeMalaysiaIdentityCardResponse ¶ 

type RecognizeMalaysiaIdentityCardResponse struct {
	*responses.BaseResponse
	RequestId string                              `json:"RequestId" xml:"RequestId"`
	Code      string                              `json:"Code" xml:"Code"`
	Message   string                              `json:"Message" xml:"Message"`
	Data      DataInRecognizeMalaysiaIdentityCard `json:"Data" xml:"Data"`
}

RecognizeMalaysiaIdentityCardResponse is the response struct for api RecognizeMalaysiaIdentityCard

func CreateRecognizeMalaysiaIdentityCardResponse ¶ 

func CreateRecognizeMalaysiaIdentityCardResponse() (response *RecognizeMalaysiaIdentityCardResponse)

CreateRecognizeMalaysiaIdentityCardResponse creates a response to parse from RecognizeMalaysiaIdentityCard response

type RecognizePassportMRZRequest ¶ 

type RecognizePassportMRZRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RecognizePassportMRZRequest is the request struct for api RecognizePassportMRZ

func CreateRecognizePassportMRZRequest ¶ 

func CreateRecognizePassportMRZRequest() (request *RecognizePassportMRZRequest)

CreateRecognizePassportMRZRequest creates a request to invoke RecognizePassportMRZ API

type RecognizePassportMRZResponse ¶ 

type RecognizePassportMRZResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizePassportMRZResponse is the response struct for api RecognizePassportMRZ

func CreateRecognizePassportMRZResponse ¶ 

func CreateRecognizePassportMRZResponse() (response *RecognizePassportMRZResponse)

CreateRecognizePassportMRZResponse creates a response to parse from RecognizePassportMRZ response

type RecognizePdfRequest ¶ 

type RecognizePdfRequest struct {
	*requests.RpcRequest
	FileURL string `position:"Body" name:"FileURL"`
}

RecognizePdfRequest is the request struct for api RecognizePdf

func CreateRecognizePdfRequest ¶ 

func CreateRecognizePdfRequest() (request *RecognizePdfRequest)

CreateRecognizePdfRequest creates a request to invoke RecognizePdf API

type RecognizePdfResponse ¶ 

type RecognizePdfResponse struct {
	*responses.BaseResponse
	RequestId string             `json:"RequestId" xml:"RequestId"`
	Code      string             `json:"Code" xml:"Code"`
	Message   string             `json:"Message" xml:"Message"`
	Data      DataInRecognizePdf `json:"Data" xml:"Data"`
}

RecognizePdfResponse is the response struct for api RecognizePdf

func CreateRecognizePdfResponse ¶ 

func CreateRecognizePdfResponse() (response *RecognizePdfResponse)

CreateRecognizePdfResponse creates a response to parse from RecognizePdf response

type RecognizePoiNameRequest ¶ 

type RecognizePoiNameRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RecognizePoiNameRequest is the request struct for api RecognizePoiName

func CreateRecognizePoiNameRequest ¶ 

func CreateRecognizePoiNameRequest() (request *RecognizePoiNameRequest)

CreateRecognizePoiNameRequest creates a request to invoke RecognizePoiName API

type RecognizePoiNameResponse ¶ 

type RecognizePoiNameResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizePoiNameResponse is the response struct for api RecognizePoiName

func CreateRecognizePoiNameResponse ¶ 

func CreateRecognizePoiNameResponse() (response *RecognizePoiNameResponse)

CreateRecognizePoiNameResponse creates a response to parse from RecognizePoiName response

type RecognizeQrCodeRequest ¶ 

type RecognizeQrCodeRequest struct {
	*requests.RpcRequest
	Tasks *[]RecognizeQrCodeTasks `position:"Body" name:"Tasks"  type:"Repeated"`
}

RecognizeQrCodeRequest is the request struct for api RecognizeQrCode

func CreateRecognizeQrCodeRequest ¶ 

func CreateRecognizeQrCodeRequest() (request *RecognizeQrCodeRequest)

CreateRecognizeQrCodeRequest creates a request to invoke RecognizeQrCode API

type RecognizeQrCodeResponse ¶ 

type RecognizeQrCodeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeQrCodeResponse is the response struct for api RecognizeQrCode

func CreateRecognizeQrCodeResponse ¶ 

func CreateRecognizeQrCodeResponse() (response *RecognizeQrCodeResponse)

CreateRecognizeQrCodeResponse creates a response to parse from RecognizeQrCode response

type RecognizeQrCodeTasks ¶ 

type RecognizeQrCodeTasks struct {
	ImageURL string `name:"ImageURL"`
}

RecognizeQrCodeTasks is a repeated param struct in RecognizeQrCodeRequest

type RecognizeQuotaInvoiceRequest ¶ 

type RecognizeQuotaInvoiceRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RecognizeQuotaInvoiceRequest is the request struct for api RecognizeQuotaInvoice

func CreateRecognizeQuotaInvoiceRequest ¶ 

func CreateRecognizeQuotaInvoiceRequest() (request *RecognizeQuotaInvoiceRequest)

CreateRecognizeQuotaInvoiceRequest creates a request to invoke RecognizeQuotaInvoice API

type RecognizeQuotaInvoiceResponse ¶ 

type RecognizeQuotaInvoiceResponse struct {
	*responses.BaseResponse
	RequestId string                      `json:"RequestId" xml:"RequestId"`
	Code      string                      `json:"Code" xml:"Code"`
	Message   string                      `json:"Message" xml:"Message"`
	Data      DataInRecognizeQuotaInvoice `json:"Data" xml:"Data"`
}

RecognizeQuotaInvoiceResponse is the response struct for api RecognizeQuotaInvoice

func CreateRecognizeQuotaInvoiceResponse ¶ 

func CreateRecognizeQuotaInvoiceResponse() (response *RecognizeQuotaInvoiceResponse)

CreateRecognizeQuotaInvoiceResponse creates a response to parse from RecognizeQuotaInvoice response

type RecognizeRussiaIdentityCardRequest ¶ 

type RecognizeRussiaIdentityCardRequest struct {
	*requests.RpcRequest
	ImageUrl string `position:"Body" name:"ImageUrl"`
}

RecognizeRussiaIdentityCardRequest is the request struct for api RecognizeRussiaIdentityCard

func CreateRecognizeRussiaIdentityCardRequest ¶ 

func CreateRecognizeRussiaIdentityCardRequest() (request *RecognizeRussiaIdentityCardRequest)

CreateRecognizeRussiaIdentityCardRequest creates a request to invoke RecognizeRussiaIdentityCard API

type RecognizeRussiaIdentityCardResponse ¶ 

type RecognizeRussiaIdentityCardResponse struct {
	*responses.BaseResponse
	RequestId string                            `json:"RequestId" xml:"RequestId"`
	Code      string                            `json:"Code" xml:"Code"`
	Message   string                            `json:"Message" xml:"Message"`
	Data      DataInRecognizeRussiaIdentityCard `json:"Data" xml:"Data"`
}

RecognizeRussiaIdentityCardResponse is the response struct for api RecognizeRussiaIdentityCard

func CreateRecognizeRussiaIdentityCardResponse ¶ 

func CreateRecognizeRussiaIdentityCardResponse() (response *RecognizeRussiaIdentityCardResponse)

CreateRecognizeRussiaIdentityCardResponse creates a response to parse from RecognizeRussiaIdentityCard response

type RecognizeStampRequest ¶ 

type RecognizeStampRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeStampRequest is the request struct for api RecognizeStamp

func CreateRecognizeStampRequest ¶ 

func CreateRecognizeStampRequest() (request *RecognizeStampRequest)

CreateRecognizeStampRequest creates a request to invoke RecognizeStamp API

type RecognizeStampResponse ¶ 

type RecognizeStampResponse struct {
	*responses.BaseResponse
	RequestId string               `json:"RequestId" xml:"RequestId"`
	Data      DataInRecognizeStamp `json:"Data" xml:"Data"`
}

RecognizeStampResponse is the response struct for api RecognizeStamp

func CreateRecognizeStampResponse ¶ 

func CreateRecognizeStampResponse() (response *RecognizeStampResponse)

CreateRecognizeStampResponse creates a response to parse from RecognizeStamp response

type RecognizeTableRequest ¶ 

type RecognizeTableRequest struct {
	*requests.RpcRequest
	UseFinanceModel requests.Boolean `position:"Body" name:"UseFinanceModel"`
	SkipDetection   requests.Boolean `position:"Body" name:"SkipDetection"`
	OutputFormat    string           `position:"Body" name:"OutputFormat"`
	AssureDirection requests.Boolean `position:"Body" name:"AssureDirection"`
	HasLine         requests.Boolean `position:"Body" name:"HasLine"`
	ImageType       requests.Integer `position:"Body" name:"ImageType"`
	ImageURL        string           `position:"Body" name:"ImageURL"`
}

RecognizeTableRequest is the request struct for api RecognizeTable

func CreateRecognizeTableRequest ¶ 

func CreateRecognizeTableRequest() (request *RecognizeTableRequest)

CreateRecognizeTableRequest creates a request to invoke RecognizeTable API

type RecognizeTableResponse ¶ 

type RecognizeTableResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeTableResponse is the response struct for api RecognizeTable

func CreateRecognizeTableResponse ¶ 

func CreateRecognizeTableResponse() (response *RecognizeTableResponse)

CreateRecognizeTableResponse creates a response to parse from RecognizeTable response

type RecognizeTakeoutOrderRequest ¶ 

type RecognizeTakeoutOrderRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RecognizeTakeoutOrderRequest is the request struct for api RecognizeTakeoutOrder

func CreateRecognizeTakeoutOrderRequest ¶ 

func CreateRecognizeTakeoutOrderRequest() (request *RecognizeTakeoutOrderRequest)

CreateRecognizeTakeoutOrderRequest creates a request to invoke RecognizeTakeoutOrder API

type RecognizeTakeoutOrderResponse ¶ 

type RecognizeTakeoutOrderResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeTakeoutOrderResponse is the response struct for api RecognizeTakeoutOrder

func CreateRecognizeTakeoutOrderResponse ¶ 

func CreateRecognizeTakeoutOrderResponse() (response *RecognizeTakeoutOrderResponse)

CreateRecognizeTakeoutOrderResponse creates a response to parse from RecognizeTakeoutOrder response

type RecognizeTaxiInvoiceRequest ¶ 

type RecognizeTaxiInvoiceRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeTaxiInvoiceRequest is the request struct for api RecognizeTaxiInvoice

func CreateRecognizeTaxiInvoiceRequest ¶ 

func CreateRecognizeTaxiInvoiceRequest() (request *RecognizeTaxiInvoiceRequest)

CreateRecognizeTaxiInvoiceRequest creates a request to invoke RecognizeTaxiInvoice API

type RecognizeTaxiInvoiceResponse ¶ 

type RecognizeTaxiInvoiceResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeTaxiInvoiceResponse is the response struct for api RecognizeTaxiInvoice

func CreateRecognizeTaxiInvoiceResponse ¶ 

func CreateRecognizeTaxiInvoiceResponse() (response *RecognizeTaxiInvoiceResponse)

CreateRecognizeTaxiInvoiceResponse creates a response to parse from RecognizeTaxiInvoice response

type RecognizeTicketInvoiceRequest ¶ 

type RecognizeTicketInvoiceRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RecognizeTicketInvoiceRequest is the request struct for api RecognizeTicketInvoice

func CreateRecognizeTicketInvoiceRequest ¶ 

func CreateRecognizeTicketInvoiceRequest() (request *RecognizeTicketInvoiceRequest)

CreateRecognizeTicketInvoiceRequest creates a request to invoke RecognizeTicketInvoice API

type RecognizeTicketInvoiceResponse ¶ 

type RecognizeTicketInvoiceResponse struct {
	*responses.BaseResponse
	RequestId string                       `json:"RequestId" xml:"RequestId"`
	Code      string                       `json:"Code" xml:"Code"`
	Message   string                       `json:"Message" xml:"Message"`
	Data      DataInRecognizeTicketInvoice `json:"Data" xml:"Data"`
}

RecognizeTicketInvoiceResponse is the response struct for api RecognizeTicketInvoice

func CreateRecognizeTicketInvoiceResponse ¶ 

func CreateRecognizeTicketInvoiceResponse() (response *RecognizeTicketInvoiceResponse)

CreateRecognizeTicketInvoiceResponse creates a response to parse from RecognizeTicketInvoice response

type RecognizeTrainTicketRequest ¶ 

type RecognizeTrainTicketRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Body" name:"ImageType"`
	ImageURL  string           `position:"Body" name:"ImageURL"`
}

RecognizeTrainTicketRequest is the request struct for api RecognizeTrainTicket

func CreateRecognizeTrainTicketRequest ¶ 

func CreateRecognizeTrainTicketRequest() (request *RecognizeTrainTicketRequest)

CreateRecognizeTrainTicketRequest creates a request to invoke RecognizeTrainTicket API

type RecognizeTrainTicketResponse ¶ 

type RecognizeTrainTicketResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeTrainTicketResponse is the response struct for api RecognizeTrainTicket

func CreateRecognizeTrainTicketResponse ¶ 

func CreateRecognizeTrainTicketResponse() (response *RecognizeTrainTicketResponse)

CreateRecognizeTrainTicketResponse creates a response to parse from RecognizeTrainTicket response

type RecognizeTurkeyIdentityCardRequest ¶ 

type RecognizeTurkeyIdentityCardRequest struct {
	*requests.RpcRequest
	ImageUrl string `position:"Body" name:"ImageUrl"`
}

RecognizeTurkeyIdentityCardRequest is the request struct for api RecognizeTurkeyIdentityCard

func CreateRecognizeTurkeyIdentityCardRequest ¶ 

func CreateRecognizeTurkeyIdentityCardRequest() (request *RecognizeTurkeyIdentityCardRequest)

CreateRecognizeTurkeyIdentityCardRequest creates a request to invoke RecognizeTurkeyIdentityCard API

type RecognizeTurkeyIdentityCardResponse ¶ 

type RecognizeTurkeyIdentityCardResponse struct {
	*responses.BaseResponse
	RequestId string                            `json:"RequestId" xml:"RequestId"`
	Code      string                            `json:"Code" xml:"Code"`
	Message   string                            `json:"Message" xml:"Message"`
	Data      DataInRecognizeTurkeyIdentityCard `json:"Data" xml:"Data"`
}

RecognizeTurkeyIdentityCardResponse is the response struct for api RecognizeTurkeyIdentityCard

func CreateRecognizeTurkeyIdentityCardResponse ¶ 

func CreateRecognizeTurkeyIdentityCardResponse() (response *RecognizeTurkeyIdentityCardResponse)

CreateRecognizeTurkeyIdentityCardResponse creates a response to parse from RecognizeTurkeyIdentityCard response

type RecognizeUkraineIdentityCardRequest ¶ 

type RecognizeUkraineIdentityCardRequest struct {
	*requests.RpcRequest
	ImageUrl string `position:"Body" name:"ImageUrl"`
}

RecognizeUkraineIdentityCardRequest is the request struct for api RecognizeUkraineIdentityCard

func CreateRecognizeUkraineIdentityCardRequest ¶ 

func CreateRecognizeUkraineIdentityCardRequest() (request *RecognizeUkraineIdentityCardRequest)

CreateRecognizeUkraineIdentityCardRequest creates a request to invoke RecognizeUkraineIdentityCard API

type RecognizeUkraineIdentityCardResponse ¶ 

type RecognizeUkraineIdentityCardResponse struct {
	*responses.BaseResponse
	RequestId string                             `json:"RequestId" xml:"RequestId"`
	Code      string                             `json:"Code" xml:"Code"`
	Message   string                             `json:"Message" xml:"Message"`
	Data      DataInRecognizeUkraineIdentityCard `json:"Data" xml:"Data"`
}

RecognizeUkraineIdentityCardResponse is the response struct for api RecognizeUkraineIdentityCard

func CreateRecognizeUkraineIdentityCardResponse ¶ 

func CreateRecognizeUkraineIdentityCardResponse() (response *RecognizeUkraineIdentityCardResponse)

CreateRecognizeUkraineIdentityCardResponse creates a response to parse from RecognizeUkraineIdentityCard response

type RecognizeVATInvoiceRequest ¶ 

type RecognizeVATInvoiceRequest struct {
	*requests.RpcRequest
	FileType string `position:"Body" name:"FileType"`
	FileURL  string `position:"Body" name:"FileURL"`
}

RecognizeVATInvoiceRequest is the request struct for api RecognizeVATInvoice

func CreateRecognizeVATInvoiceRequest ¶ 

func CreateRecognizeVATInvoiceRequest() (request *RecognizeVATInvoiceRequest)

CreateRecognizeVATInvoiceRequest creates a request to invoke RecognizeVATInvoice API

type RecognizeVATInvoiceResponse ¶ 

type RecognizeVATInvoiceResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeVATInvoiceResponse is the response struct for api RecognizeVATInvoice

func CreateRecognizeVATInvoiceResponse ¶ 

func CreateRecognizeVATInvoiceResponse() (response *RecognizeVATInvoiceResponse)

CreateRecognizeVATInvoiceResponse creates a response to parse from RecognizeVATInvoice response

type RecognizeVINCodeRequest ¶ 

type RecognizeVINCodeRequest struct {
	*requests.RpcRequest
	ImageType requests.Integer `position:"Query" name:"ImageType"`
	ImageURL  string           `position:"Query" name:"ImageURL"`
}

RecognizeVINCodeRequest is the request struct for api RecognizeVINCode

func CreateRecognizeVINCodeRequest ¶ 

func CreateRecognizeVINCodeRequest() (request *RecognizeVINCodeRequest)

CreateRecognizeVINCodeRequest creates a request to invoke RecognizeVINCode API

type RecognizeVINCodeResponse ¶ 

type RecognizeVINCodeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeVINCodeResponse is the response struct for api RecognizeVINCode

func CreateRecognizeVINCodeResponse ¶ 

func CreateRecognizeVINCodeResponse() (response *RecognizeVINCodeResponse)

CreateRecognizeVINCodeResponse creates a response to parse from RecognizeVINCode response

type RecognizeVerificationcodeRequest ¶ 

type RecognizeVerificationcodeRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RecognizeVerificationcodeRequest is the request struct for api RecognizeVerificationcode

func CreateRecognizeVerificationcodeRequest ¶ 

func CreateRecognizeVerificationcodeRequest() (request *RecognizeVerificationcodeRequest)

CreateRecognizeVerificationcodeRequest creates a request to invoke RecognizeVerificationcode API

type RecognizeVerificationcodeResponse ¶ 

type RecognizeVerificationcodeResponse struct {
	*responses.BaseResponse
	RequestId string                          `json:"RequestId" xml:"RequestId"`
	Data      DataInRecognizeVerificationcode `json:"Data" xml:"Data"`
}

RecognizeVerificationcodeResponse is the response struct for api RecognizeVerificationcode

func CreateRecognizeVerificationcodeResponse ¶ 

func CreateRecognizeVerificationcodeResponse() (response *RecognizeVerificationcodeResponse)

CreateRecognizeVerificationcodeResponse creates a response to parse from RecognizeVerificationcode response

type RecognizeVideoCastCrewListParams ¶ 

type RecognizeVideoCastCrewListParams struct {
	Type string `name:"Type"`
}

RecognizeVideoCastCrewListParams is a repeated param struct in RecognizeVideoCastCrewListRequest

type RecognizeVideoCastCrewListRequest ¶ 

type RecognizeVideoCastCrewListRequest struct {
	*requests.RpcRequest
	Params      *[]RecognizeVideoCastCrewListParams `position:"Body" name:"Params"  type:"Json"`
	Async       requests.Boolean                    `position:"Body" name:"Async"`
	RegisterUrl string                              `position:"Body" name:"RegisterUrl"`
	VideoUrl    string                              `position:"Body" name:"VideoUrl"`
}

RecognizeVideoCastCrewListRequest is the request struct for api RecognizeVideoCastCrewList

func CreateRecognizeVideoCastCrewListRequest ¶ 

func CreateRecognizeVideoCastCrewListRequest() (request *RecognizeVideoCastCrewListRequest)

CreateRecognizeVideoCastCrewListRequest creates a request to invoke RecognizeVideoCastCrewList API

type RecognizeVideoCastCrewListResponse ¶ 

type RecognizeVideoCastCrewListResponse struct {
	*responses.BaseResponse
}

RecognizeVideoCastCrewListResponse is the response struct for api RecognizeVideoCastCrewList

func CreateRecognizeVideoCastCrewListResponse ¶ 

func CreateRecognizeVideoCastCrewListResponse() (response *RecognizeVideoCastCrewListResponse)

CreateRecognizeVideoCastCrewListResponse creates a response to parse from RecognizeVideoCastCrewList response

type RecognizeVideoCharacterRequest ¶ 

type RecognizeVideoCharacterRequest struct {
	*requests.RpcRequest
	Async    requests.Boolean `position:"Body" name:"Async"`
	VideoURL string           `position:"Body" name:"VideoURL"`
}

RecognizeVideoCharacterRequest is the request struct for api RecognizeVideoCharacter

func CreateRecognizeVideoCharacterRequest ¶ 

func CreateRecognizeVideoCharacterRequest() (request *RecognizeVideoCharacterRequest)

CreateRecognizeVideoCharacterRequest creates a request to invoke RecognizeVideoCharacter API

type RecognizeVideoCharacterResponse ¶ 

type RecognizeVideoCharacterResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecognizeVideoCharacterResponse is the response struct for api RecognizeVideoCharacter

func CreateRecognizeVideoCharacterResponse ¶ 

func CreateRecognizeVideoCharacterResponse() (response *RecognizeVideoCharacterResponse)

CreateRecognizeVideoCharacterResponse creates a response to parse from RecognizeVideoCharacter response

type RecognizeVietnamIdentityCardRequest ¶ 

type RecognizeVietnamIdentityCardRequest struct {
	*requests.RpcRequest
	ImageUrl string `position:"Body" name:"ImageUrl"`
}

RecognizeVietnamIdentityCardRequest is the request struct for api RecognizeVietnamIdentityCard

func CreateRecognizeVietnamIdentityCardRequest ¶ 

func CreateRecognizeVietnamIdentityCardRequest() (request *RecognizeVietnamIdentityCardRequest)

CreateRecognizeVietnamIdentityCardRequest creates a request to invoke RecognizeVietnamIdentityCard API

type RecognizeVietnamIdentityCardResponse ¶ 

type RecognizeVietnamIdentityCardResponse struct {
	*responses.BaseResponse
	RequestId string                             `json:"RequestId" xml:"RequestId"`
	Code      string                             `json:"Code" xml:"Code"`
	Message   string                             `json:"Message" xml:"Message"`
	Data      DataInRecognizeVietnamIdentityCard `json:"Data" xml:"Data"`
}

RecognizeVietnamIdentityCardResponse is the response struct for api RecognizeVietnamIdentityCard

func CreateRecognizeVietnamIdentityCardResponse ¶ 

func CreateRecognizeVietnamIdentityCardResponse() (response *RecognizeVietnamIdentityCardResponse)

CreateRecognizeVietnamIdentityCardResponse creates a response to parse from RecognizeVietnamIdentityCard response

type RecordNumber ¶ 

type RecordNumber struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

RecordNumber is a nested struct in ocr response

type Region ¶ 

type Region struct {
	RecognitionScore float64   `json:"RecognitionScore" xml:"RecognitionScore"`
	DetectionScore   float64   `json:"DetectionScore" xml:"DetectionScore"`
	Name             string    `json:"Name" xml:"Name"`
	Content          string    `json:"Content" xml:"Content"`
	BandBoxes        []float64 `json:"BandBoxes" xml:"BandBoxes"`
}

Region is a nested struct in ocr response

type Regions ¶ 

type Regions struct {
	Region []Region `json:"Region" xml:"Region"`
}

Regions is a nested struct in ocr response

type RegisterNumber ¶ 

type RegisterNumber struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

RegisterNumber is a nested struct in ocr response

type RegisterStampArea ¶ 

type RegisterStampArea struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

RegisterStampArea is a nested struct in ocr response

type RegisterStampAreas ¶ 

type RegisterStampAreas struct {
	RegisterStampArea []RegisterStampArea `json:"RegisterStampArea" xml:"RegisterStampArea"`
}

RegisterStampAreas is a nested struct in ocr response

type Religion ¶ 

type Religion struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Religion is a nested struct in ocr response

type ReligionInRecognizeTurkeyIdentityCard ¶ 

type ReligionInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ReligionInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type ResidencePlaceFirstLine ¶ 

type ResidencePlaceFirstLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ResidencePlaceFirstLine is a nested struct in ocr response

type ResidencePlaceSecondLine ¶ 

type ResidencePlaceSecondLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ResidencePlaceSecondLine is a nested struct in ocr response

type Result ¶ 

type Result struct {
	Rate           float64        `json:"Rate" xml:"Rate"`
	Text           string         `json:"Text" xml:"Text"`
	Suggestion     string         `json:"Suggestion" xml:"Suggestion"`
	Label          string         `json:"Label" xml:"Label"`
	Probability    float64        `json:"Probability" xml:"Probability"`
	QrCodesData    []string       `json:"QrCodesData" xml:"QrCodesData"`
	TextRectangles TextRectangles `json:"TextRectangles" xml:"TextRectangles"`
}

Result is a nested struct in ocr response

type ResultMap ¶ 

type ResultMap struct {
	ScreenThreshold float64 `json:"ScreenThreshold" xml:"ScreenThreshold"`
	ScreenScore     float64 `json:"ScreenScore" xml:"ScreenScore"`
}

ResultMap is a nested struct in ocr response

type Results ¶ 

type Results struct {
	Index          int64            `json:"Index" xml:"Index"`
	Type           string           `json:"Type" xml:"Type"`
	Content        Content          `json:"Content" xml:"Content"`
	SliceRectangle []SliceRectangle `json:"SliceRectangle" xml:"SliceRectangle"`
	KeyValueInfos  []KeyValueInfos  `json:"KeyValueInfos" xml:"KeyValueInfos"`
}

Results is a nested struct in ocr response

type ResultsInRecognizeCharacter ¶ 

type ResultsInRecognizeCharacter struct {
	Result []Result `json:"Result" xml:"Result"`
}

ResultsInRecognizeCharacter is a nested struct in ocr response

type ResultsInRecognizeQrCode ¶ 

type ResultsInRecognizeQrCode struct {
	Result []Result `json:"Result" xml:"Result"`
}

ResultsInRecognizeQrCode is a nested struct in ocr response

type ResultsInRecognizeStamp ¶ 

type ResultsInRecognizeStamp struct {
	ResultsItem []ResultsItem `json:"Results" xml:"Results"`
}

ResultsInRecognizeStamp is a nested struct in ocr response

type ResultsInRecognizeTicketInvoice ¶ 

type ResultsInRecognizeTicketInvoice struct {
	Results []Results `json:"results" xml:"results"`
}

ResultsInRecognizeTicketInvoice is a nested struct in ocr response

type ResultsItem ¶ 

type ResultsItem struct {
	Text        Text              `json:"Text" xml:"Text"`
	Roi         Roi               `json:"Roi" xml:"Roi"`
	GeneralText []GeneralTextItem `json:"GeneralText" xml:"GeneralText"`
}

ResultsItem is a nested struct in ocr response

type Roi ¶ 

type Roi struct {
	H      int `json:"H" xml:"H"`
	X      int `json:"X" xml:"X"`
	W      int `json:"W" xml:"W"`
	Y      int `json:"Y" xml:"Y"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Top    int `json:"Top" xml:"Top"`
	Left   int `json:"Left" xml:"Left"`
}

Roi is a nested struct in ocr response

type Sayfa ¶ 

type Sayfa struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Sayfa is a nested struct in ocr response

type Seri ¶ 

type Seri struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Seri is a nested struct in ocr response

type Sex ¶ 

type Sex struct {
	Score     string      `json:"Score" xml:"Score"`
	Text      string      `json:"Text" xml:"Text"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Sex is a nested struct in ocr response

type SexInRecognizeTurkeyIdentityCard ¶ 

type SexInRecognizeTurkeyIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

SexInRecognizeTurkeyIdentityCard is a nested struct in ocr response

type SexInRecognizeUkraineIdentityCard ¶ 

type SexInRecognizeUkraineIdentityCard struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

SexInRecognizeUkraineIdentityCard is a nested struct in ocr response

type Signboards ¶ 

type Signboards struct {
	SignboardsItem []SignboardsItem `json:"Signboards" xml:"Signboards"`
}

Signboards is a nested struct in ocr response

type SignboardsItem ¶ 

type SignboardsItem struct {
	Texts []TextsItem `json:"Texts" xml:"Texts"`
}

SignboardsItem is a nested struct in ocr response

type Size ¶ 

type Size struct {
	H      float64 `json:"H" xml:"H"`
	W      float64 `json:"W" xml:"W"`
	Height float64 `json:"Height" xml:"Height"`
	Width  float64 `json:"Width" xml:"Width"`
}

Size is a nested struct in ocr response

type SliceRectangle ¶ 

type SliceRectangle struct {
	Y int64 `json:"Y" xml:"Y"`
	X int64 `json:"X" xml:"X"`
}

SliceRectangle is a nested struct in ocr response

type SliceRectangleInRecognizeTicketInvoice ¶ 

type SliceRectangleInRecognizeTicketInvoice struct {
	SliceRectangle []SliceRectangle `json:"sliceRectangle" xml:"sliceRectangle"`
}

SliceRectangleInRecognizeTicketInvoice is a nested struct in ocr response

type SpoofResult ¶ 

type SpoofResult struct {
	IsSpoof   bool      `json:"IsSpoof" xml:"IsSpoof"`
	ResultMap ResultMap `json:"ResultMap" xml:"ResultMap"`
}

SpoofResult is a nested struct in ocr response

type Stamp ¶ 

type Stamp struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

Stamp is a nested struct in ocr response

type SumAmounts ¶ 

type SumAmounts struct {
	SumAmount []float64 `json:"SumAmount" xml:"SumAmount"`
}

SumAmounts is a nested struct in ocr response

type Summary ¶ 

type Summary struct {
	Brand string  `json:"Brand" xml:"Brand"`
	Score float64 `json:"Score" xml:"Score"`
}

Summary is a nested struct in ocr response

type Surname ¶ 

type Surname struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Surname is a nested struct in ocr response

type SurnameEnglish ¶ 

type SurnameEnglish struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

SurnameEnglish is a nested struct in ocr response

type SurnameFirstLine ¶ 

type SurnameFirstLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

SurnameFirstLine is a nested struct in ocr response

type SurnameSecondLine ¶ 

type SurnameSecondLine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     string      `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

SurnameSecondLine is a nested struct in ocr response

type SurnameUkraine ¶ 

type SurnameUkraine struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

SurnameUkraine is a nested struct in ocr response

type Table ¶ 

type Table struct {
	Head      []string   `json:"Head" xml:"Head"`
	Tail      []string   `json:"Tail" xml:"Tail"`
	TableRows []TableRow `json:"TableRows" xml:"TableRows"`
}

Table is a nested struct in ocr response

type TableColumn ¶ 

type TableColumn struct {
	EndRow      int      `json:"EndRow" xml:"EndRow"`
	EndColumn   int      `json:"EndColumn" xml:"EndColumn"`
	Width       int      `json:"Width" xml:"Width"`
	Height      int      `json:"Height" xml:"Height"`
	StartRow    int      `json:"StartRow" xml:"StartRow"`
	StartColumn int      `json:"StartColumn" xml:"StartColumn"`
	Texts       []string `json:"Texts" xml:"Texts"`
}

TableColumn is a nested struct in ocr response

type TableColumns ¶ 

type TableColumns struct {
	TableColumn []TableColumn `json:"TableColumn" xml:"TableColumn"`
}

TableColumns is a nested struct in ocr response

type TableRow ¶ 

type TableRow struct {
	TableColumns []TableColumn `json:"TableColumns" xml:"TableColumns"`
}

TableRow is a nested struct in ocr response

type TableRows ¶ 

type TableRows struct {
	TableRow []TableRow `json:"TableRow" xml:"TableRow"`
}

TableRows is a nested struct in ocr response

type Tables ¶ 

type Tables struct {
	Table []Table `json:"Table" xml:"Table"`
}

Tables is a nested struct in ocr response

type Tail ¶ 

type Tail struct {
	Tail []string `json:"Tail" xml:"Tail"`
}

Tail is a nested struct in ocr response

type TaxAmounts ¶ 

type TaxAmounts struct {
	TaxAmount []float64 `json:"TaxAmount" xml:"TaxAmount"`
}

TaxAmounts is a nested struct in ocr response

type Text ¶ 

type Text struct {
	Confidence float64 `json:"Confidence" xml:"Confidence"`
	Content    string  `json:"Content" xml:"Content"`
}

Text is a nested struct in ocr response

type TextRectangle ¶ 

type TextRectangle struct {
	Angle  int64 `json:"Angle" xml:"Angle"`
	Left   int64 `json:"Left" xml:"Left"`
	Top    int64 `json:"Top" xml:"Top"`
	Width  int64 `json:"Width" xml:"Width"`
	Height int64 `json:"Height" xml:"Height"`
}

TextRectangle is a nested struct in ocr response

type TextRectangles ¶ 

type TextRectangles struct {
	Angle  int `json:"Angle" xml:"Angle"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Top    int `json:"Top" xml:"Top"`
	Left   int `json:"Left" xml:"Left"`
}

TextRectangles is a nested struct in ocr response

type TextRectanglesInRecognizeVideoCharacter ¶ 

type TextRectanglesInRecognizeVideoCharacter struct {
	TextRectangle []TextRectangle `json:"TextRectangle" xml:"TextRectangle"`
}

TextRectanglesInRecognizeVideoCharacter is a nested struct in ocr response

type TextsInRecognizePoiName ¶ 

type TextsInRecognizePoiName struct {
	TextsItem []TextsItem `json:"Texts" xml:"Texts"`
}

TextsInRecognizePoiName is a nested struct in ocr response

type TextsInRecognizeTable ¶ 

type TextsInRecognizeTable struct {
	Text []string `json:"Text" xml:"Text"`
}

TextsInRecognizeTable is a nested struct in ocr response

type TextsItem ¶ 

type TextsItem struct {
	Type   string  `json:"Type" xml:"Type"`
	Score  float64 `json:"Score" xml:"Score"`
	Tag    string  `json:"Tag" xml:"Tag"`
	Label  string  `json:"Label" xml:"Label"`
	Points []int   `json:"Points" xml:"Points"`
}

TextsItem is a nested struct in ocr response

type Title ¶ 

type Title struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

Title is a nested struct in ocr response

type TitleArea ¶ 

type TitleArea struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

TitleArea is a nested struct in ocr response

type Titles ¶ 

type Titles struct {
	Title []string `json:"Title" xml:"Title"`
}

Titles is a nested struct in ocr response

type TrimDocumentRequest ¶ 

type TrimDocumentRequest struct {
	*requests.RpcRequest
	FileType   string           `position:"Body" name:"FileType"`
	OutputType string           `position:"Body" name:"OutputType"`
	Async      requests.Boolean `position:"Body" name:"Async"`
	FileURL    string           `position:"Body" name:"FileURL"`
}

TrimDocumentRequest is the request struct for api TrimDocument

func CreateTrimDocumentRequest ¶ 

func CreateTrimDocumentRequest() (request *TrimDocumentRequest)

CreateTrimDocumentRequest creates a request to invoke TrimDocument API

type TrimDocumentResponse ¶ 

type TrimDocumentResponse struct {
	*responses.BaseResponse
	RequestId string             `json:"RequestId" xml:"RequestId"`
	Code      string             `json:"Code" xml:"Code"`
	Message   string             `json:"Message" xml:"Message"`
	Data      DataInTrimDocument `json:"Data" xml:"Data"`
}

TrimDocumentResponse is the response struct for api TrimDocument

func CreateTrimDocumentResponse ¶ 

func CreateTrimDocumentResponse() (response *TrimDocumentResponse)

CreateTrimDocumentResponse creates a response to parse from TrimDocument response

type TypeOfResidencePermit ¶ 

type TypeOfResidencePermit struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

TypeOfResidencePermit is a nested struct in ocr response

type UndertakeStampArea ¶ 

type UndertakeStampArea struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

UndertakeStampArea is a nested struct in ocr response

type UndertakeStampAreas ¶ 

type UndertakeStampAreas struct {
	UndertakeStampArea []UndertakeStampArea `json:"UndertakeStampArea" xml:"UndertakeStampArea"`
}

UndertakeStampAreas is a nested struct in ocr response

type ValidUntil ¶ 

type ValidUntil struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

ValidUntil is a nested struct in ocr response

type ValuePositions ¶ 

type ValuePositions struct {
	Y int64 `json:"Y" xml:"Y"`
	X int64 `json:"X" xml:"X"`
}

ValuePositions is a nested struct in ocr response

type ValuePositionsInRecognizeQuotaInvoice ¶ 

type ValuePositionsInRecognizeQuotaInvoice struct {
	ValuePositions []ValuePositions `json:"valuePositions" xml:"valuePositions"`
}

ValuePositionsInRecognizeQuotaInvoice is a nested struct in ocr response

type ValuePositionsInRecognizeTicketInvoice ¶ 

type ValuePositionsInRecognizeTicketInvoice struct {
	ValuePositions []ValuePositions `json:"valuePositions" xml:"valuePositions"`
}

ValuePositionsInRecognizeTicketInvoice is a nested struct in ocr response

type Village ¶ 

type Village struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

Village is a nested struct in ocr response

type VolumeNumber ¶ 

type VolumeNumber struct {
	Text      string      `json:"Text" xml:"Text"`
	Score     float64     `json:"Score" xml:"Score"`
	KeyPoints []KeyPoints `json:"KeyPoints" xml:"KeyPoints"`
}

VolumeNumber is a nested struct in ocr response

type WithoutTaxAmounts ¶ 

type WithoutTaxAmounts struct {
	WithoutTaxAmount []float64 `json:"WithoutTaxAmount" xml:"WithoutTaxAmount"`
}

WithoutTaxAmounts is a nested struct in ocr response

type WordsInfo ¶ 

type WordsInfo struct {
	Y         int64       `json:"Y" xml:"Y"`
	Width     int64       `json:"Width" xml:"Width"`
	X         int64       `json:"X" xml:"X"`
	Word      string      `json:"Word" xml:"Word"`
	Angle     int64       `json:"Angle" xml:"Angle"`
	Height    int64       `json:"Height" xml:"Height"`
	Positions []Positions `json:"Positions" xml:"Positions"`
}

WordsInfo is a nested struct in ocr response

type WordsInfoInRecognizePdf ¶ 

type WordsInfoInRecognizePdf struct {
	WordsInfo []WordsInfo `json:"wordsInfo" xml:"wordsInfo"`
}

WordsInfoInRecognizePdf is a nested struct in ocr response

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.