Source file src/github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.0/computervision/client.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.0/computervision

     1  // Package computervision implements the Azure ARM Computervision service API version 2.0.
     2  //
     3  // The Computer Vision API provides state-of-the-art algorithms to process images and return information. For example,
     4  // it can be used to determine if an image contains mature content, or it can be used to find all the faces in an
     5  // image.  It also has other features like estimating dominant and accent colors, categorizing the content of images,
     6  // and describing an image with complete English sentences.  Additionally, it can also intelligently generate images
     7  // thumbnails for displaying large images effectively.
     8  package computervision
     9  
    10  // Copyright (c) Microsoft Corporation. All rights reserved.
    11  // Licensed under the MIT License. See License.txt in the project root for license information.
    12  //
    13  // Code generated by Microsoft (R) AutoRest Code Generator.
    14  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
    15  
    16  import (
    17  	"context"
    18  	"github.com/Azure/go-autorest/autorest"
    19  	"github.com/Azure/go-autorest/autorest/azure"
    20  	"github.com/Azure/go-autorest/autorest/validation"
    21  	"github.com/Azure/go-autorest/tracing"
    22  	"io"
    23  	"net/http"
    24  )
    25  
    26  // BaseClient is the base client for Computervision.
    27  type BaseClient struct {
    28  	autorest.Client
    29  	Endpoint string
    30  }
    31  
    32  // New creates an instance of the BaseClient client.
    33  func New(endpoint string) BaseClient {
    34  	return NewWithoutDefaults(endpoint)
    35  }
    36  
    37  // NewWithoutDefaults creates an instance of the BaseClient client.
    38  func NewWithoutDefaults(endpoint string) BaseClient {
    39  	return BaseClient{
    40  		Client:   autorest.NewClientWithUserAgent(UserAgent()),
    41  		Endpoint: endpoint,
    42  	}
    43  }
    44  
    45  // AnalyzeImage this operation extracts a rich set of visual features based on the image content.
    46  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL. Within your request, there
    47  // is an optional parameter to allow you to choose which features to return. By default, image categories are returned
    48  // in the response.
    49  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
    50  // message to help understand what went wrong.
    51  // Parameters:
    52  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
    53  // visualFeatures - a string indicating what visual feature types to return. Multiple values should be
    54  // comma-separated. Valid visual feature types include: Categories - categorizes image content according to a
    55  // taxonomy defined in documentation. Tags - tags the image with a detailed list of words related to the image
    56  // content. Description - describes the image content with a complete English sentence. Faces - detects if
    57  // faces are present. If present, generate coordinates, gender and age. ImageType - detects if image is clipart
    58  // or a line drawing. Color - determines the accent color, dominant color, and whether an image is black&white.
    59  // Adult - detects if the image is pornographic in nature (depicts nudity or a sex act).  Sexually suggestive
    60  // content is also detected. Objects - detects various objects within an image, including the approximate
    61  // location. The Objects argument is only available in English. Brands - detects various brands within an
    62  // image, including the approximate location. The Brands argument is only available in English.
    63  // details - a string indicating which domain-specific details to return. Multiple values should be
    64  // comma-separated. Valid visual feature types include: Celebrities - identifies celebrities if detected in the
    65  // image, Landmarks - identifies notable landmarks in the image.
    66  // language - the desired language for output generation. If this parameter is not specified, the default value
    67  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
    68  // zh - Simplified Chinese.
    69  func (client BaseClient) AnalyzeImage(ctx context.Context, imageURL ImageURL, visualFeatures []VisualFeatureTypes, details []Details, language string) (result ImageAnalysis, err error) {
    70  	if tracing.IsEnabled() {
    71  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.AnalyzeImage")
    72  		defer func() {
    73  			sc := -1
    74  			if result.Response.Response != nil {
    75  				sc = result.Response.Response.StatusCode
    76  			}
    77  			tracing.EndSpan(ctx, sc, err)
    78  		}()
    79  	}
    80  	if err := validation.Validate([]validation.Validation{
    81  		{TargetValue: imageURL,
    82  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
    83  		return result, validation.NewError("computervision.BaseClient", "AnalyzeImage", err.Error())
    84  	}
    85  
    86  	req, err := client.AnalyzeImagePreparer(ctx, imageURL, visualFeatures, details, language)
    87  	if err != nil {
    88  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImage", nil, "Failure preparing request")
    89  		return
    90  	}
    91  
    92  	resp, err := client.AnalyzeImageSender(req)
    93  	if err != nil {
    94  		result.Response = autorest.Response{Response: resp}
    95  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImage", resp, "Failure sending request")
    96  		return
    97  	}
    98  
    99  	result, err = client.AnalyzeImageResponder(resp)
   100  	if err != nil {
   101  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImage", resp, "Failure responding to request")
   102  		return
   103  	}
   104  
   105  	return
   106  }
   107  
   108  // AnalyzeImagePreparer prepares the AnalyzeImage request.
   109  func (client BaseClient) AnalyzeImagePreparer(ctx context.Context, imageURL ImageURL, visualFeatures []VisualFeatureTypes, details []Details, language string) (*http.Request, error) {
   110  	urlParameters := map[string]interface{}{
   111  		"Endpoint": client.Endpoint,
   112  	}
   113  
   114  	queryParameters := map[string]interface{}{}
   115  	if visualFeatures != nil && len(visualFeatures) > 0 {
   116  		queryParameters["visualFeatures"] = autorest.Encode("query", visualFeatures, ",")
   117  	}
   118  	if details != nil && len(details) > 0 {
   119  		queryParameters["details"] = autorest.Encode("query", details, ",")
   120  	}
   121  	if len(string(language)) > 0 {
   122  		queryParameters["language"] = autorest.Encode("query", language)
   123  	} else {
   124  		queryParameters["language"] = autorest.Encode("query", "en")
   125  	}
   126  
   127  	preparer := autorest.CreatePreparer(
   128  		autorest.AsContentType("application/json; charset=utf-8"),
   129  		autorest.AsPost(),
   130  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   131  		autorest.WithPath("/analyze"),
   132  		autorest.WithJSON(imageURL),
   133  		autorest.WithQueryParameters(queryParameters))
   134  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   135  }
   136  
   137  // AnalyzeImageSender sends the AnalyzeImage request. The method will close the
   138  // http.Response Body if it receives an error.
   139  func (client BaseClient) AnalyzeImageSender(req *http.Request) (*http.Response, error) {
   140  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   141  }
   142  
   143  // AnalyzeImageResponder handles the response to the AnalyzeImage request. The method always
   144  // closes the http.Response Body.
   145  func (client BaseClient) AnalyzeImageResponder(resp *http.Response) (result ImageAnalysis, err error) {
   146  	err = autorest.Respond(
   147  		resp,
   148  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   149  		autorest.ByUnmarshallingJSON(&result),
   150  		autorest.ByClosing())
   151  	result.Response = autorest.Response{Response: resp}
   152  	return
   153  }
   154  
   155  // AnalyzeImageByDomain this operation recognizes content within an image by applying a domain-specific model. The list
   156  // of domain-specific models that are supported by the Computer Vision API can be retrieved using the /models GET
   157  // request. Currently, the API provides following domain-specific models: celebrities, landmarks.
   158  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
   159  // A successful response will be returned in JSON.
   160  // If the request failed, the response will contain an error code and a message to help understand what went wrong.
   161  // Parameters:
   162  // model - the domain-specific content to recognize.
   163  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
   164  // language - the desired language for output generation. If this parameter is not specified, the default value
   165  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
   166  // zh - Simplified Chinese.
   167  func (client BaseClient) AnalyzeImageByDomain(ctx context.Context, model string, imageURL ImageURL, language string) (result DomainModelResults, err error) {
   168  	if tracing.IsEnabled() {
   169  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.AnalyzeImageByDomain")
   170  		defer func() {
   171  			sc := -1
   172  			if result.Response.Response != nil {
   173  				sc = result.Response.Response.StatusCode
   174  			}
   175  			tracing.EndSpan(ctx, sc, err)
   176  		}()
   177  	}
   178  	if err := validation.Validate([]validation.Validation{
   179  		{TargetValue: imageURL,
   180  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   181  		return result, validation.NewError("computervision.BaseClient", "AnalyzeImageByDomain", err.Error())
   182  	}
   183  
   184  	req, err := client.AnalyzeImageByDomainPreparer(ctx, model, imageURL, language)
   185  	if err != nil {
   186  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageByDomain", nil, "Failure preparing request")
   187  		return
   188  	}
   189  
   190  	resp, err := client.AnalyzeImageByDomainSender(req)
   191  	if err != nil {
   192  		result.Response = autorest.Response{Response: resp}
   193  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageByDomain", resp, "Failure sending request")
   194  		return
   195  	}
   196  
   197  	result, err = client.AnalyzeImageByDomainResponder(resp)
   198  	if err != nil {
   199  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageByDomain", resp, "Failure responding to request")
   200  		return
   201  	}
   202  
   203  	return
   204  }
   205  
   206  // AnalyzeImageByDomainPreparer prepares the AnalyzeImageByDomain request.
   207  func (client BaseClient) AnalyzeImageByDomainPreparer(ctx context.Context, model string, imageURL ImageURL, language string) (*http.Request, error) {
   208  	urlParameters := map[string]interface{}{
   209  		"Endpoint": client.Endpoint,
   210  	}
   211  
   212  	pathParameters := map[string]interface{}{
   213  		"model": autorest.Encode("path", model),
   214  	}
   215  
   216  	queryParameters := map[string]interface{}{}
   217  	if len(string(language)) > 0 {
   218  		queryParameters["language"] = autorest.Encode("query", language)
   219  	} else {
   220  		queryParameters["language"] = autorest.Encode("query", "en")
   221  	}
   222  
   223  	preparer := autorest.CreatePreparer(
   224  		autorest.AsContentType("application/json; charset=utf-8"),
   225  		autorest.AsPost(),
   226  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   227  		autorest.WithPathParameters("/models/{model}/analyze", pathParameters),
   228  		autorest.WithJSON(imageURL),
   229  		autorest.WithQueryParameters(queryParameters))
   230  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   231  }
   232  
   233  // AnalyzeImageByDomainSender sends the AnalyzeImageByDomain request. The method will close the
   234  // http.Response Body if it receives an error.
   235  func (client BaseClient) AnalyzeImageByDomainSender(req *http.Request) (*http.Response, error) {
   236  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   237  }
   238  
   239  // AnalyzeImageByDomainResponder handles the response to the AnalyzeImageByDomain request. The method always
   240  // closes the http.Response Body.
   241  func (client BaseClient) AnalyzeImageByDomainResponder(resp *http.Response) (result DomainModelResults, err error) {
   242  	err = autorest.Respond(
   243  		resp,
   244  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   245  		autorest.ByUnmarshallingJSON(&result),
   246  		autorest.ByClosing())
   247  	result.Response = autorest.Response{Response: resp}
   248  	return
   249  }
   250  
   251  // AnalyzeImageByDomainInStream this operation recognizes content within an image by applying a domain-specific model.
   252  // The list of domain-specific models that are supported by the Computer Vision API can be retrieved using the /models
   253  // GET request. Currently, the API provides following domain-specific models: celebrities, landmarks.
   254  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
   255  // A successful response will be returned in JSON.
   256  // If the request failed, the response will contain an error code and a message to help understand what went wrong.
   257  // Parameters:
   258  // model - the domain-specific content to recognize.
   259  // imageParameter - an image stream.
   260  // language - the desired language for output generation. If this parameter is not specified, the default value
   261  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
   262  // zh - Simplified Chinese.
   263  func (client BaseClient) AnalyzeImageByDomainInStream(ctx context.Context, model string, imageParameter io.ReadCloser, language string) (result DomainModelResults, err error) {
   264  	if tracing.IsEnabled() {
   265  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.AnalyzeImageByDomainInStream")
   266  		defer func() {
   267  			sc := -1
   268  			if result.Response.Response != nil {
   269  				sc = result.Response.Response.StatusCode
   270  			}
   271  			tracing.EndSpan(ctx, sc, err)
   272  		}()
   273  	}
   274  	req, err := client.AnalyzeImageByDomainInStreamPreparer(ctx, model, imageParameter, language)
   275  	if err != nil {
   276  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageByDomainInStream", nil, "Failure preparing request")
   277  		return
   278  	}
   279  
   280  	resp, err := client.AnalyzeImageByDomainInStreamSender(req)
   281  	if err != nil {
   282  		result.Response = autorest.Response{Response: resp}
   283  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageByDomainInStream", resp, "Failure sending request")
   284  		return
   285  	}
   286  
   287  	result, err = client.AnalyzeImageByDomainInStreamResponder(resp)
   288  	if err != nil {
   289  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageByDomainInStream", resp, "Failure responding to request")
   290  		return
   291  	}
   292  
   293  	return
   294  }
   295  
   296  // AnalyzeImageByDomainInStreamPreparer prepares the AnalyzeImageByDomainInStream request.
   297  func (client BaseClient) AnalyzeImageByDomainInStreamPreparer(ctx context.Context, model string, imageParameter io.ReadCloser, language string) (*http.Request, error) {
   298  	urlParameters := map[string]interface{}{
   299  		"Endpoint": client.Endpoint,
   300  	}
   301  
   302  	pathParameters := map[string]interface{}{
   303  		"model": autorest.Encode("path", model),
   304  	}
   305  
   306  	queryParameters := map[string]interface{}{}
   307  	if len(string(language)) > 0 {
   308  		queryParameters["language"] = autorest.Encode("query", language)
   309  	} else {
   310  		queryParameters["language"] = autorest.Encode("query", "en")
   311  	}
   312  
   313  	preparer := autorest.CreatePreparer(
   314  		autorest.AsContentType("application/octet-stream"),
   315  		autorest.AsPost(),
   316  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   317  		autorest.WithPathParameters("/models/{model}/analyze", pathParameters),
   318  		autorest.WithFile(imageParameter),
   319  		autorest.WithQueryParameters(queryParameters))
   320  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   321  }
   322  
   323  // AnalyzeImageByDomainInStreamSender sends the AnalyzeImageByDomainInStream request. The method will close the
   324  // http.Response Body if it receives an error.
   325  func (client BaseClient) AnalyzeImageByDomainInStreamSender(req *http.Request) (*http.Response, error) {
   326  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   327  }
   328  
   329  // AnalyzeImageByDomainInStreamResponder handles the response to the AnalyzeImageByDomainInStream request. The method always
   330  // closes the http.Response Body.
   331  func (client BaseClient) AnalyzeImageByDomainInStreamResponder(resp *http.Response) (result DomainModelResults, err error) {
   332  	err = autorest.Respond(
   333  		resp,
   334  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   335  		autorest.ByUnmarshallingJSON(&result),
   336  		autorest.ByClosing())
   337  	result.Response = autorest.Response{Response: resp}
   338  	return
   339  }
   340  
   341  // AnalyzeImageInStream this operation extracts a rich set of visual features based on the image content.
   342  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL. Within your request, there
   343  // is an optional parameter to allow you to choose which features to return. By default, image categories are returned
   344  // in the response.
   345  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
   346  // message to help understand what went wrong.
   347  // Parameters:
   348  // imageParameter - an image stream.
   349  // visualFeatures - a string indicating what visual feature types to return. Multiple values should be
   350  // comma-separated. Valid visual feature types include: Categories - categorizes image content according to a
   351  // taxonomy defined in documentation. Tags - tags the image with a detailed list of words related to the image
   352  // content. Description - describes the image content with a complete English sentence. Faces - detects if
   353  // faces are present. If present, generate coordinates, gender and age. ImageType - detects if image is clipart
   354  // or a line drawing. Color - determines the accent color, dominant color, and whether an image is black&white.
   355  // Adult - detects if the image is pornographic in nature (depicts nudity or a sex act).  Sexually suggestive
   356  // content is also detected. Objects - detects various objects within an image, including the approximate
   357  // location. The Objects argument is only available in English. Brands - detects various brands within an
   358  // image, including the approximate location. The Brands argument is only available in English.
   359  // details - a string indicating which domain-specific details to return. Multiple values should be
   360  // comma-separated. Valid visual feature types include: Celebrities - identifies celebrities if detected in the
   361  // image, Landmarks - identifies notable landmarks in the image.
   362  // language - the desired language for output generation. If this parameter is not specified, the default value
   363  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
   364  // zh - Simplified Chinese.
   365  func (client BaseClient) AnalyzeImageInStream(ctx context.Context, imageParameter io.ReadCloser, visualFeatures []VisualFeatureTypes, details []Details, language string) (result ImageAnalysis, err error) {
   366  	if tracing.IsEnabled() {
   367  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.AnalyzeImageInStream")
   368  		defer func() {
   369  			sc := -1
   370  			if result.Response.Response != nil {
   371  				sc = result.Response.Response.StatusCode
   372  			}
   373  			tracing.EndSpan(ctx, sc, err)
   374  		}()
   375  	}
   376  	req, err := client.AnalyzeImageInStreamPreparer(ctx, imageParameter, visualFeatures, details, language)
   377  	if err != nil {
   378  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageInStream", nil, "Failure preparing request")
   379  		return
   380  	}
   381  
   382  	resp, err := client.AnalyzeImageInStreamSender(req)
   383  	if err != nil {
   384  		result.Response = autorest.Response{Response: resp}
   385  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageInStream", resp, "Failure sending request")
   386  		return
   387  	}
   388  
   389  	result, err = client.AnalyzeImageInStreamResponder(resp)
   390  	if err != nil {
   391  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "AnalyzeImageInStream", resp, "Failure responding to request")
   392  		return
   393  	}
   394  
   395  	return
   396  }
   397  
   398  // AnalyzeImageInStreamPreparer prepares the AnalyzeImageInStream request.
   399  func (client BaseClient) AnalyzeImageInStreamPreparer(ctx context.Context, imageParameter io.ReadCloser, visualFeatures []VisualFeatureTypes, details []Details, language string) (*http.Request, error) {
   400  	urlParameters := map[string]interface{}{
   401  		"Endpoint": client.Endpoint,
   402  	}
   403  
   404  	queryParameters := map[string]interface{}{}
   405  	if visualFeatures != nil && len(visualFeatures) > 0 {
   406  		queryParameters["visualFeatures"] = autorest.Encode("query", visualFeatures, ",")
   407  	}
   408  	if details != nil && len(details) > 0 {
   409  		queryParameters["details"] = autorest.Encode("query", details, ",")
   410  	}
   411  	if len(string(language)) > 0 {
   412  		queryParameters["language"] = autorest.Encode("query", language)
   413  	} else {
   414  		queryParameters["language"] = autorest.Encode("query", "en")
   415  	}
   416  
   417  	preparer := autorest.CreatePreparer(
   418  		autorest.AsContentType("application/octet-stream"),
   419  		autorest.AsPost(),
   420  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   421  		autorest.WithPath("/analyze"),
   422  		autorest.WithFile(imageParameter),
   423  		autorest.WithQueryParameters(queryParameters))
   424  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   425  }
   426  
   427  // AnalyzeImageInStreamSender sends the AnalyzeImageInStream request. The method will close the
   428  // http.Response Body if it receives an error.
   429  func (client BaseClient) AnalyzeImageInStreamSender(req *http.Request) (*http.Response, error) {
   430  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   431  }
   432  
   433  // AnalyzeImageInStreamResponder handles the response to the AnalyzeImageInStream request. The method always
   434  // closes the http.Response Body.
   435  func (client BaseClient) AnalyzeImageInStreamResponder(resp *http.Response) (result ImageAnalysis, err error) {
   436  	err = autorest.Respond(
   437  		resp,
   438  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   439  		autorest.ByUnmarshallingJSON(&result),
   440  		autorest.ByClosing())
   441  	result.Response = autorest.Response{Response: resp}
   442  	return
   443  }
   444  
   445  // BatchReadFile use this interface to get the result of a Read operation, employing the state-of-the-art Optical
   446  // Character Recognition (OCR) algorithms optimized for text-heavy documents. When you use the Read File interface, the
   447  // response contains a field called 'Operation-Location'. The 'Operation-Location' field contains the URL that you must
   448  // use for your 'GetReadOperationResult' operation to access OCR results.​
   449  // Parameters:
   450  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
   451  func (client BaseClient) BatchReadFile(ctx context.Context, imageURL ImageURL) (result autorest.Response, err error) {
   452  	if tracing.IsEnabled() {
   453  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.BatchReadFile")
   454  		defer func() {
   455  			sc := -1
   456  			if result.Response != nil {
   457  				sc = result.Response.StatusCode
   458  			}
   459  			tracing.EndSpan(ctx, sc, err)
   460  		}()
   461  	}
   462  	if err := validation.Validate([]validation.Validation{
   463  		{TargetValue: imageURL,
   464  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   465  		return result, validation.NewError("computervision.BaseClient", "BatchReadFile", err.Error())
   466  	}
   467  
   468  	req, err := client.BatchReadFilePreparer(ctx, imageURL)
   469  	if err != nil {
   470  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "BatchReadFile", nil, "Failure preparing request")
   471  		return
   472  	}
   473  
   474  	resp, err := client.BatchReadFileSender(req)
   475  	if err != nil {
   476  		result.Response = resp
   477  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "BatchReadFile", resp, "Failure sending request")
   478  		return
   479  	}
   480  
   481  	result, err = client.BatchReadFileResponder(resp)
   482  	if err != nil {
   483  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "BatchReadFile", resp, "Failure responding to request")
   484  		return
   485  	}
   486  
   487  	return
   488  }
   489  
   490  // BatchReadFilePreparer prepares the BatchReadFile request.
   491  func (client BaseClient) BatchReadFilePreparer(ctx context.Context, imageURL ImageURL) (*http.Request, error) {
   492  	urlParameters := map[string]interface{}{
   493  		"Endpoint": client.Endpoint,
   494  	}
   495  
   496  	preparer := autorest.CreatePreparer(
   497  		autorest.AsContentType("application/json; charset=utf-8"),
   498  		autorest.AsPost(),
   499  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   500  		autorest.WithPath("/read/core/asyncBatchAnalyze"),
   501  		autorest.WithJSON(imageURL))
   502  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   503  }
   504  
   505  // BatchReadFileSender sends the BatchReadFile request. The method will close the
   506  // http.Response Body if it receives an error.
   507  func (client BaseClient) BatchReadFileSender(req *http.Request) (*http.Response, error) {
   508  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   509  }
   510  
   511  // BatchReadFileResponder handles the response to the BatchReadFile request. The method always
   512  // closes the http.Response Body.
   513  func (client BaseClient) BatchReadFileResponder(resp *http.Response) (result autorest.Response, err error) {
   514  	err = autorest.Respond(
   515  		resp,
   516  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   517  		autorest.ByClosing())
   518  	result.Response = resp
   519  	return
   520  }
   521  
   522  // BatchReadFileInStream use this interface to get the result of a Read Document operation, employing the
   523  // state-of-the-art Optical Character Recognition (OCR) algorithms optimized for text-heavy documents. When you use the
   524  // Read Document interface, the response contains a field called 'Operation-Location'. The 'Operation-Location' field
   525  // contains the URL that you must use for your 'Get Read Result operation' to access OCR results.​
   526  // Parameters:
   527  // imageParameter - an image stream.
   528  func (client BaseClient) BatchReadFileInStream(ctx context.Context, imageParameter io.ReadCloser) (result autorest.Response, err error) {
   529  	if tracing.IsEnabled() {
   530  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.BatchReadFileInStream")
   531  		defer func() {
   532  			sc := -1
   533  			if result.Response != nil {
   534  				sc = result.Response.StatusCode
   535  			}
   536  			tracing.EndSpan(ctx, sc, err)
   537  		}()
   538  	}
   539  	req, err := client.BatchReadFileInStreamPreparer(ctx, imageParameter)
   540  	if err != nil {
   541  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "BatchReadFileInStream", nil, "Failure preparing request")
   542  		return
   543  	}
   544  
   545  	resp, err := client.BatchReadFileInStreamSender(req)
   546  	if err != nil {
   547  		result.Response = resp
   548  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "BatchReadFileInStream", resp, "Failure sending request")
   549  		return
   550  	}
   551  
   552  	result, err = client.BatchReadFileInStreamResponder(resp)
   553  	if err != nil {
   554  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "BatchReadFileInStream", resp, "Failure responding to request")
   555  		return
   556  	}
   557  
   558  	return
   559  }
   560  
   561  // BatchReadFileInStreamPreparer prepares the BatchReadFileInStream request.
   562  func (client BaseClient) BatchReadFileInStreamPreparer(ctx context.Context, imageParameter io.ReadCloser) (*http.Request, error) {
   563  	urlParameters := map[string]interface{}{
   564  		"Endpoint": client.Endpoint,
   565  	}
   566  
   567  	preparer := autorest.CreatePreparer(
   568  		autorest.AsContentType("application/octet-stream"),
   569  		autorest.AsPost(),
   570  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   571  		autorest.WithPath("/read/core/asyncBatchAnalyze"),
   572  		autorest.WithFile(imageParameter))
   573  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   574  }
   575  
   576  // BatchReadFileInStreamSender sends the BatchReadFileInStream request. The method will close the
   577  // http.Response Body if it receives an error.
   578  func (client BaseClient) BatchReadFileInStreamSender(req *http.Request) (*http.Response, error) {
   579  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   580  }
   581  
   582  // BatchReadFileInStreamResponder handles the response to the BatchReadFileInStream request. The method always
   583  // closes the http.Response Body.
   584  func (client BaseClient) BatchReadFileInStreamResponder(resp *http.Response) (result autorest.Response, err error) {
   585  	err = autorest.Respond(
   586  		resp,
   587  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   588  		autorest.ByClosing())
   589  	result.Response = resp
   590  	return
   591  }
   592  
   593  // DescribeImage this operation generates a description of an image in human readable language with complete sentences.
   594  // The description is based on a collection of content tags, which are also returned by the operation. More than one
   595  // description can be generated for each image. Descriptions are ordered by their confidence score. All descriptions
   596  // are in English.
   597  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
   598  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
   599  // message to help understand what went wrong.
   600  // Parameters:
   601  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
   602  // maxCandidates - maximum number of candidate descriptions to be returned.  The default is 1.
   603  // language - the desired language for output generation. If this parameter is not specified, the default value
   604  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
   605  // zh - Simplified Chinese.
   606  func (client BaseClient) DescribeImage(ctx context.Context, imageURL ImageURL, maxCandidates *int32, language string) (result ImageDescription, err error) {
   607  	if tracing.IsEnabled() {
   608  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DescribeImage")
   609  		defer func() {
   610  			sc := -1
   611  			if result.Response.Response != nil {
   612  				sc = result.Response.Response.StatusCode
   613  			}
   614  			tracing.EndSpan(ctx, sc, err)
   615  		}()
   616  	}
   617  	if err := validation.Validate([]validation.Validation{
   618  		{TargetValue: imageURL,
   619  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   620  		return result, validation.NewError("computervision.BaseClient", "DescribeImage", err.Error())
   621  	}
   622  
   623  	req, err := client.DescribeImagePreparer(ctx, imageURL, maxCandidates, language)
   624  	if err != nil {
   625  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DescribeImage", nil, "Failure preparing request")
   626  		return
   627  	}
   628  
   629  	resp, err := client.DescribeImageSender(req)
   630  	if err != nil {
   631  		result.Response = autorest.Response{Response: resp}
   632  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DescribeImage", resp, "Failure sending request")
   633  		return
   634  	}
   635  
   636  	result, err = client.DescribeImageResponder(resp)
   637  	if err != nil {
   638  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DescribeImage", resp, "Failure responding to request")
   639  		return
   640  	}
   641  
   642  	return
   643  }
   644  
   645  // DescribeImagePreparer prepares the DescribeImage request.
   646  func (client BaseClient) DescribeImagePreparer(ctx context.Context, imageURL ImageURL, maxCandidates *int32, language string) (*http.Request, error) {
   647  	urlParameters := map[string]interface{}{
   648  		"Endpoint": client.Endpoint,
   649  	}
   650  
   651  	queryParameters := map[string]interface{}{}
   652  	if maxCandidates != nil {
   653  		queryParameters["maxCandidates"] = autorest.Encode("query", *maxCandidates)
   654  	} else {
   655  		queryParameters["maxCandidates"] = autorest.Encode("query", 1)
   656  	}
   657  	if len(string(language)) > 0 {
   658  		queryParameters["language"] = autorest.Encode("query", language)
   659  	} else {
   660  		queryParameters["language"] = autorest.Encode("query", "en")
   661  	}
   662  
   663  	preparer := autorest.CreatePreparer(
   664  		autorest.AsContentType("application/json; charset=utf-8"),
   665  		autorest.AsPost(),
   666  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   667  		autorest.WithPath("/describe"),
   668  		autorest.WithJSON(imageURL),
   669  		autorest.WithQueryParameters(queryParameters))
   670  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   671  }
   672  
   673  // DescribeImageSender sends the DescribeImage request. The method will close the
   674  // http.Response Body if it receives an error.
   675  func (client BaseClient) DescribeImageSender(req *http.Request) (*http.Response, error) {
   676  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   677  }
   678  
   679  // DescribeImageResponder handles the response to the DescribeImage request. The method always
   680  // closes the http.Response Body.
   681  func (client BaseClient) DescribeImageResponder(resp *http.Response) (result ImageDescription, err error) {
   682  	err = autorest.Respond(
   683  		resp,
   684  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   685  		autorest.ByUnmarshallingJSON(&result),
   686  		autorest.ByClosing())
   687  	result.Response = autorest.Response{Response: resp}
   688  	return
   689  }
   690  
   691  // DescribeImageInStream this operation generates a description of an image in human readable language with complete
   692  // sentences. The description is based on a collection of content tags, which are also returned by the operation. More
   693  // than one description can be generated for each image. Descriptions are ordered by their confidence score. All
   694  // descriptions are in English.
   695  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
   696  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
   697  // message to help understand what went wrong.
   698  // Parameters:
   699  // imageParameter - an image stream.
   700  // maxCandidates - maximum number of candidate descriptions to be returned.  The default is 1.
   701  // language - the desired language for output generation. If this parameter is not specified, the default value
   702  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
   703  // zh - Simplified Chinese.
   704  func (client BaseClient) DescribeImageInStream(ctx context.Context, imageParameter io.ReadCloser, maxCandidates *int32, language string) (result ImageDescription, err error) {
   705  	if tracing.IsEnabled() {
   706  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DescribeImageInStream")
   707  		defer func() {
   708  			sc := -1
   709  			if result.Response.Response != nil {
   710  				sc = result.Response.Response.StatusCode
   711  			}
   712  			tracing.EndSpan(ctx, sc, err)
   713  		}()
   714  	}
   715  	req, err := client.DescribeImageInStreamPreparer(ctx, imageParameter, maxCandidates, language)
   716  	if err != nil {
   717  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DescribeImageInStream", nil, "Failure preparing request")
   718  		return
   719  	}
   720  
   721  	resp, err := client.DescribeImageInStreamSender(req)
   722  	if err != nil {
   723  		result.Response = autorest.Response{Response: resp}
   724  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DescribeImageInStream", resp, "Failure sending request")
   725  		return
   726  	}
   727  
   728  	result, err = client.DescribeImageInStreamResponder(resp)
   729  	if err != nil {
   730  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DescribeImageInStream", resp, "Failure responding to request")
   731  		return
   732  	}
   733  
   734  	return
   735  }
   736  
   737  // DescribeImageInStreamPreparer prepares the DescribeImageInStream request.
   738  func (client BaseClient) DescribeImageInStreamPreparer(ctx context.Context, imageParameter io.ReadCloser, maxCandidates *int32, language string) (*http.Request, error) {
   739  	urlParameters := map[string]interface{}{
   740  		"Endpoint": client.Endpoint,
   741  	}
   742  
   743  	queryParameters := map[string]interface{}{}
   744  	if maxCandidates != nil {
   745  		queryParameters["maxCandidates"] = autorest.Encode("query", *maxCandidates)
   746  	} else {
   747  		queryParameters["maxCandidates"] = autorest.Encode("query", 1)
   748  	}
   749  	if len(string(language)) > 0 {
   750  		queryParameters["language"] = autorest.Encode("query", language)
   751  	} else {
   752  		queryParameters["language"] = autorest.Encode("query", "en")
   753  	}
   754  
   755  	preparer := autorest.CreatePreparer(
   756  		autorest.AsContentType("application/octet-stream"),
   757  		autorest.AsPost(),
   758  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   759  		autorest.WithPath("/describe"),
   760  		autorest.WithFile(imageParameter),
   761  		autorest.WithQueryParameters(queryParameters))
   762  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   763  }
   764  
   765  // DescribeImageInStreamSender sends the DescribeImageInStream request. The method will close the
   766  // http.Response Body if it receives an error.
   767  func (client BaseClient) DescribeImageInStreamSender(req *http.Request) (*http.Response, error) {
   768  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   769  }
   770  
   771  // DescribeImageInStreamResponder handles the response to the DescribeImageInStream request. The method always
   772  // closes the http.Response Body.
   773  func (client BaseClient) DescribeImageInStreamResponder(resp *http.Response) (result ImageDescription, err error) {
   774  	err = autorest.Respond(
   775  		resp,
   776  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   777  		autorest.ByUnmarshallingJSON(&result),
   778  		autorest.ByClosing())
   779  	result.Response = autorest.Response{Response: resp}
   780  	return
   781  }
   782  
   783  // DetectObjects performs object detection on the specified image.
   784  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
   785  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
   786  // message to help understand what went wrong.
   787  // Parameters:
   788  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
   789  func (client BaseClient) DetectObjects(ctx context.Context, imageURL ImageURL) (result DetectResult, err error) {
   790  	if tracing.IsEnabled() {
   791  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DetectObjects")
   792  		defer func() {
   793  			sc := -1
   794  			if result.Response.Response != nil {
   795  				sc = result.Response.Response.StatusCode
   796  			}
   797  			tracing.EndSpan(ctx, sc, err)
   798  		}()
   799  	}
   800  	if err := validation.Validate([]validation.Validation{
   801  		{TargetValue: imageURL,
   802  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   803  		return result, validation.NewError("computervision.BaseClient", "DetectObjects", err.Error())
   804  	}
   805  
   806  	req, err := client.DetectObjectsPreparer(ctx, imageURL)
   807  	if err != nil {
   808  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DetectObjects", nil, "Failure preparing request")
   809  		return
   810  	}
   811  
   812  	resp, err := client.DetectObjectsSender(req)
   813  	if err != nil {
   814  		result.Response = autorest.Response{Response: resp}
   815  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DetectObjects", resp, "Failure sending request")
   816  		return
   817  	}
   818  
   819  	result, err = client.DetectObjectsResponder(resp)
   820  	if err != nil {
   821  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DetectObjects", resp, "Failure responding to request")
   822  		return
   823  	}
   824  
   825  	return
   826  }
   827  
   828  // DetectObjectsPreparer prepares the DetectObjects request.
   829  func (client BaseClient) DetectObjectsPreparer(ctx context.Context, imageURL ImageURL) (*http.Request, error) {
   830  	urlParameters := map[string]interface{}{
   831  		"Endpoint": client.Endpoint,
   832  	}
   833  
   834  	preparer := autorest.CreatePreparer(
   835  		autorest.AsContentType("application/json; charset=utf-8"),
   836  		autorest.AsPost(),
   837  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   838  		autorest.WithPath("/detect"),
   839  		autorest.WithJSON(imageURL))
   840  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   841  }
   842  
   843  // DetectObjectsSender sends the DetectObjects request. The method will close the
   844  // http.Response Body if it receives an error.
   845  func (client BaseClient) DetectObjectsSender(req *http.Request) (*http.Response, error) {
   846  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   847  }
   848  
   849  // DetectObjectsResponder handles the response to the DetectObjects request. The method always
   850  // closes the http.Response Body.
   851  func (client BaseClient) DetectObjectsResponder(resp *http.Response) (result DetectResult, err error) {
   852  	err = autorest.Respond(
   853  		resp,
   854  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   855  		autorest.ByUnmarshallingJSON(&result),
   856  		autorest.ByClosing())
   857  	result.Response = autorest.Response{Response: resp}
   858  	return
   859  }
   860  
   861  // DetectObjectsInStream performs object detection on the specified image.
   862  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
   863  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
   864  // message to help understand what went wrong.
   865  // Parameters:
   866  // imageParameter - an image stream.
   867  func (client BaseClient) DetectObjectsInStream(ctx context.Context, imageParameter io.ReadCloser) (result DetectResult, err error) {
   868  	if tracing.IsEnabled() {
   869  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DetectObjectsInStream")
   870  		defer func() {
   871  			sc := -1
   872  			if result.Response.Response != nil {
   873  				sc = result.Response.Response.StatusCode
   874  			}
   875  			tracing.EndSpan(ctx, sc, err)
   876  		}()
   877  	}
   878  	req, err := client.DetectObjectsInStreamPreparer(ctx, imageParameter)
   879  	if err != nil {
   880  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DetectObjectsInStream", nil, "Failure preparing request")
   881  		return
   882  	}
   883  
   884  	resp, err := client.DetectObjectsInStreamSender(req)
   885  	if err != nil {
   886  		result.Response = autorest.Response{Response: resp}
   887  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DetectObjectsInStream", resp, "Failure sending request")
   888  		return
   889  	}
   890  
   891  	result, err = client.DetectObjectsInStreamResponder(resp)
   892  	if err != nil {
   893  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "DetectObjectsInStream", resp, "Failure responding to request")
   894  		return
   895  	}
   896  
   897  	return
   898  }
   899  
   900  // DetectObjectsInStreamPreparer prepares the DetectObjectsInStream request.
   901  func (client BaseClient) DetectObjectsInStreamPreparer(ctx context.Context, imageParameter io.ReadCloser) (*http.Request, error) {
   902  	urlParameters := map[string]interface{}{
   903  		"Endpoint": client.Endpoint,
   904  	}
   905  
   906  	preparer := autorest.CreatePreparer(
   907  		autorest.AsContentType("application/octet-stream"),
   908  		autorest.AsPost(),
   909  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
   910  		autorest.WithPath("/detect"),
   911  		autorest.WithFile(imageParameter))
   912  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   913  }
   914  
   915  // DetectObjectsInStreamSender sends the DetectObjectsInStream request. The method will close the
   916  // http.Response Body if it receives an error.
   917  func (client BaseClient) DetectObjectsInStreamSender(req *http.Request) (*http.Response, error) {
   918  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   919  }
   920  
   921  // DetectObjectsInStreamResponder handles the response to the DetectObjectsInStream request. The method always
   922  // closes the http.Response Body.
   923  func (client BaseClient) DetectObjectsInStreamResponder(resp *http.Response) (result DetectResult, err error) {
   924  	err = autorest.Respond(
   925  		resp,
   926  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   927  		autorest.ByUnmarshallingJSON(&result),
   928  		autorest.ByClosing())
   929  	result.Response = autorest.Response{Response: resp}
   930  	return
   931  }
   932  
   933  // GenerateThumbnail this operation generates a thumbnail image with the user-specified width and height. By default,
   934  // the service analyzes the image, identifies the region of interest (ROI), and generates smart cropping coordinates
   935  // based on the ROI. Smart cropping helps when you specify an aspect ratio that differs from that of the input image.
   936  // A successful response contains the thumbnail image binary. If the request failed, the response contains an error
   937  // code and a message to help determine what went wrong.
   938  // Upon failure, the error code and an error message are returned. The error code could be one of InvalidImageUrl,
   939  // InvalidImageFormat, InvalidImageSize, InvalidThumbnailSize, NotSupportedImage, FailedToProcess, Timeout, or
   940  // InternalServerError.
   941  // Parameters:
   942  // width - width of the thumbnail, in pixels. It must be between 1 and 1024. Recommended minimum of 50.
   943  // height - height of the thumbnail, in pixels. It must be between 1 and 1024. Recommended minimum of 50.
   944  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
   945  // smartCropping - boolean flag for enabling smart cropping.
   946  func (client BaseClient) GenerateThumbnail(ctx context.Context, width int32, height int32, imageURL ImageURL, smartCropping *bool) (result ReadCloser, err error) {
   947  	if tracing.IsEnabled() {
   948  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GenerateThumbnail")
   949  		defer func() {
   950  			sc := -1
   951  			if result.Response.Response != nil {
   952  				sc = result.Response.Response.StatusCode
   953  			}
   954  			tracing.EndSpan(ctx, sc, err)
   955  		}()
   956  	}
   957  	if err := validation.Validate([]validation.Validation{
   958  		{TargetValue: width,
   959  			Constraints: []validation.Constraint{{Target: "width", Name: validation.InclusiveMaximum, Rule: int64(1024), Chain: nil},
   960  				{Target: "width", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   961  		{TargetValue: height,
   962  			Constraints: []validation.Constraint{{Target: "height", Name: validation.InclusiveMaximum, Rule: int64(1024), Chain: nil},
   963  				{Target: "height", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   964  		{TargetValue: imageURL,
   965  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   966  		return result, validation.NewError("computervision.BaseClient", "GenerateThumbnail", err.Error())
   967  	}
   968  
   969  	req, err := client.GenerateThumbnailPreparer(ctx, width, height, imageURL, smartCropping)
   970  	if err != nil {
   971  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GenerateThumbnail", nil, "Failure preparing request")
   972  		return
   973  	}
   974  
   975  	resp, err := client.GenerateThumbnailSender(req)
   976  	if err != nil {
   977  		result.Response = autorest.Response{Response: resp}
   978  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GenerateThumbnail", resp, "Failure sending request")
   979  		return
   980  	}
   981  
   982  	result, err = client.GenerateThumbnailResponder(resp)
   983  	if err != nil {
   984  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GenerateThumbnail", resp, "Failure responding to request")
   985  		return
   986  	}
   987  
   988  	return
   989  }
   990  
   991  // GenerateThumbnailPreparer prepares the GenerateThumbnail request.
   992  func (client BaseClient) GenerateThumbnailPreparer(ctx context.Context, width int32, height int32, imageURL ImageURL, smartCropping *bool) (*http.Request, error) {
   993  	urlParameters := map[string]interface{}{
   994  		"Endpoint": client.Endpoint,
   995  	}
   996  
   997  	queryParameters := map[string]interface{}{
   998  		"height": autorest.Encode("query", height),
   999  		"width":  autorest.Encode("query", width),
  1000  	}
  1001  	if smartCropping != nil {
  1002  		queryParameters["smartCropping"] = autorest.Encode("query", *smartCropping)
  1003  	} else {
  1004  		queryParameters["smartCropping"] = autorest.Encode("query", false)
  1005  	}
  1006  
  1007  	preparer := autorest.CreatePreparer(
  1008  		autorest.AsContentType("application/json; charset=utf-8"),
  1009  		autorest.AsPost(),
  1010  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1011  		autorest.WithPath("/generateThumbnail"),
  1012  		autorest.WithJSON(imageURL),
  1013  		autorest.WithQueryParameters(queryParameters))
  1014  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1015  }
  1016  
  1017  // GenerateThumbnailSender sends the GenerateThumbnail request. The method will close the
  1018  // http.Response Body if it receives an error.
  1019  func (client BaseClient) GenerateThumbnailSender(req *http.Request) (*http.Response, error) {
  1020  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1021  }
  1022  
  1023  // GenerateThumbnailResponder handles the response to the GenerateThumbnail request. The method always
  1024  // closes the http.Response Body.
  1025  func (client BaseClient) GenerateThumbnailResponder(resp *http.Response) (result ReadCloser, err error) {
  1026  	result.Value = &resp.Body
  1027  	err = autorest.Respond(
  1028  		resp,
  1029  		azure.WithErrorUnlessStatusCode(http.StatusOK))
  1030  	result.Response = autorest.Response{Response: resp}
  1031  	return
  1032  }
  1033  
  1034  // GenerateThumbnailInStream this operation generates a thumbnail image with the user-specified width and height. By
  1035  // default, the service analyzes the image, identifies the region of interest (ROI), and generates smart cropping
  1036  // coordinates based on the ROI. Smart cropping helps when you specify an aspect ratio that differs from that of the
  1037  // input image.
  1038  // A successful response contains the thumbnail image binary. If the request failed, the response contains an error
  1039  // code and a message to help determine what went wrong.
  1040  // Upon failure, the error code and an error message are returned. The error code could be one of InvalidImageUrl,
  1041  // InvalidImageFormat, InvalidImageSize, InvalidThumbnailSize, NotSupportedImage, FailedToProcess, Timeout, or
  1042  // InternalServerError.
  1043  // Parameters:
  1044  // width - width of the thumbnail, in pixels. It must be between 1 and 1024. Recommended minimum of 50.
  1045  // height - height of the thumbnail, in pixels. It must be between 1 and 1024. Recommended minimum of 50.
  1046  // imageParameter - an image stream.
  1047  // smartCropping - boolean flag for enabling smart cropping.
  1048  func (client BaseClient) GenerateThumbnailInStream(ctx context.Context, width int32, height int32, imageParameter io.ReadCloser, smartCropping *bool) (result ReadCloser, err error) {
  1049  	if tracing.IsEnabled() {
  1050  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GenerateThumbnailInStream")
  1051  		defer func() {
  1052  			sc := -1
  1053  			if result.Response.Response != nil {
  1054  				sc = result.Response.Response.StatusCode
  1055  			}
  1056  			tracing.EndSpan(ctx, sc, err)
  1057  		}()
  1058  	}
  1059  	if err := validation.Validate([]validation.Validation{
  1060  		{TargetValue: width,
  1061  			Constraints: []validation.Constraint{{Target: "width", Name: validation.InclusiveMaximum, Rule: int64(1024), Chain: nil},
  1062  				{Target: "width", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
  1063  		{TargetValue: height,
  1064  			Constraints: []validation.Constraint{{Target: "height", Name: validation.InclusiveMaximum, Rule: int64(1024), Chain: nil},
  1065  				{Target: "height", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}}}); err != nil {
  1066  		return result, validation.NewError("computervision.BaseClient", "GenerateThumbnailInStream", err.Error())
  1067  	}
  1068  
  1069  	req, err := client.GenerateThumbnailInStreamPreparer(ctx, width, height, imageParameter, smartCropping)
  1070  	if err != nil {
  1071  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GenerateThumbnailInStream", nil, "Failure preparing request")
  1072  		return
  1073  	}
  1074  
  1075  	resp, err := client.GenerateThumbnailInStreamSender(req)
  1076  	if err != nil {
  1077  		result.Response = autorest.Response{Response: resp}
  1078  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GenerateThumbnailInStream", resp, "Failure sending request")
  1079  		return
  1080  	}
  1081  
  1082  	result, err = client.GenerateThumbnailInStreamResponder(resp)
  1083  	if err != nil {
  1084  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GenerateThumbnailInStream", resp, "Failure responding to request")
  1085  		return
  1086  	}
  1087  
  1088  	return
  1089  }
  1090  
  1091  // GenerateThumbnailInStreamPreparer prepares the GenerateThumbnailInStream request.
  1092  func (client BaseClient) GenerateThumbnailInStreamPreparer(ctx context.Context, width int32, height int32, imageParameter io.ReadCloser, smartCropping *bool) (*http.Request, error) {
  1093  	urlParameters := map[string]interface{}{
  1094  		"Endpoint": client.Endpoint,
  1095  	}
  1096  
  1097  	queryParameters := map[string]interface{}{
  1098  		"height": autorest.Encode("query", height),
  1099  		"width":  autorest.Encode("query", width),
  1100  	}
  1101  	if smartCropping != nil {
  1102  		queryParameters["smartCropping"] = autorest.Encode("query", *smartCropping)
  1103  	} else {
  1104  		queryParameters["smartCropping"] = autorest.Encode("query", false)
  1105  	}
  1106  
  1107  	preparer := autorest.CreatePreparer(
  1108  		autorest.AsContentType("application/octet-stream"),
  1109  		autorest.AsPost(),
  1110  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1111  		autorest.WithPath("/generateThumbnail"),
  1112  		autorest.WithFile(imageParameter),
  1113  		autorest.WithQueryParameters(queryParameters))
  1114  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1115  }
  1116  
  1117  // GenerateThumbnailInStreamSender sends the GenerateThumbnailInStream request. The method will close the
  1118  // http.Response Body if it receives an error.
  1119  func (client BaseClient) GenerateThumbnailInStreamSender(req *http.Request) (*http.Response, error) {
  1120  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1121  }
  1122  
  1123  // GenerateThumbnailInStreamResponder handles the response to the GenerateThumbnailInStream request. The method always
  1124  // closes the http.Response Body.
  1125  func (client BaseClient) GenerateThumbnailInStreamResponder(resp *http.Response) (result ReadCloser, err error) {
  1126  	result.Value = &resp.Body
  1127  	err = autorest.Respond(
  1128  		resp,
  1129  		azure.WithErrorUnlessStatusCode(http.StatusOK))
  1130  	result.Response = autorest.Response{Response: resp}
  1131  	return
  1132  }
  1133  
  1134  // GetAreaOfInterest this operation returns a bounding box around the most important area of the image.
  1135  // A successful response will be returned in JSON. If the request failed, the response contains an error code and a
  1136  // message to help determine what went wrong.
  1137  // Upon failure, the error code and an error message are returned. The error code could be one of InvalidImageUrl,
  1138  // InvalidImageFormat, InvalidImageSize, NotSupportedImage, FailedToProcess, Timeout, or InternalServerError.
  1139  // Parameters:
  1140  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
  1141  func (client BaseClient) GetAreaOfInterest(ctx context.Context, imageURL ImageURL) (result AreaOfInterestResult, err error) {
  1142  	if tracing.IsEnabled() {
  1143  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetAreaOfInterest")
  1144  		defer func() {
  1145  			sc := -1
  1146  			if result.Response.Response != nil {
  1147  				sc = result.Response.Response.StatusCode
  1148  			}
  1149  			tracing.EndSpan(ctx, sc, err)
  1150  		}()
  1151  	}
  1152  	if err := validation.Validate([]validation.Validation{
  1153  		{TargetValue: imageURL,
  1154  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1155  		return result, validation.NewError("computervision.BaseClient", "GetAreaOfInterest", err.Error())
  1156  	}
  1157  
  1158  	req, err := client.GetAreaOfInterestPreparer(ctx, imageURL)
  1159  	if err != nil {
  1160  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetAreaOfInterest", nil, "Failure preparing request")
  1161  		return
  1162  	}
  1163  
  1164  	resp, err := client.GetAreaOfInterestSender(req)
  1165  	if err != nil {
  1166  		result.Response = autorest.Response{Response: resp}
  1167  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetAreaOfInterest", resp, "Failure sending request")
  1168  		return
  1169  	}
  1170  
  1171  	result, err = client.GetAreaOfInterestResponder(resp)
  1172  	if err != nil {
  1173  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetAreaOfInterest", resp, "Failure responding to request")
  1174  		return
  1175  	}
  1176  
  1177  	return
  1178  }
  1179  
  1180  // GetAreaOfInterestPreparer prepares the GetAreaOfInterest request.
  1181  func (client BaseClient) GetAreaOfInterestPreparer(ctx context.Context, imageURL ImageURL) (*http.Request, error) {
  1182  	urlParameters := map[string]interface{}{
  1183  		"Endpoint": client.Endpoint,
  1184  	}
  1185  
  1186  	preparer := autorest.CreatePreparer(
  1187  		autorest.AsContentType("application/json; charset=utf-8"),
  1188  		autorest.AsPost(),
  1189  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1190  		autorest.WithPath("/areaOfInterest"),
  1191  		autorest.WithJSON(imageURL))
  1192  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1193  }
  1194  
  1195  // GetAreaOfInterestSender sends the GetAreaOfInterest request. The method will close the
  1196  // http.Response Body if it receives an error.
  1197  func (client BaseClient) GetAreaOfInterestSender(req *http.Request) (*http.Response, error) {
  1198  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1199  }
  1200  
  1201  // GetAreaOfInterestResponder handles the response to the GetAreaOfInterest request. The method always
  1202  // closes the http.Response Body.
  1203  func (client BaseClient) GetAreaOfInterestResponder(resp *http.Response) (result AreaOfInterestResult, err error) {
  1204  	err = autorest.Respond(
  1205  		resp,
  1206  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1207  		autorest.ByUnmarshallingJSON(&result),
  1208  		autorest.ByClosing())
  1209  	result.Response = autorest.Response{Response: resp}
  1210  	return
  1211  }
  1212  
  1213  // GetAreaOfInterestInStream this operation returns a bounding box around the most important area of the image.
  1214  // A successful response will be returned in JSON. If the request failed, the response contains an error code and a
  1215  // message to help determine what went wrong.
  1216  // Upon failure, the error code and an error message are returned. The error code could be one of InvalidImageUrl,
  1217  // InvalidImageFormat, InvalidImageSize, NotSupportedImage, FailedToProcess, Timeout, or InternalServerError.
  1218  // Parameters:
  1219  // imageParameter - an image stream.
  1220  func (client BaseClient) GetAreaOfInterestInStream(ctx context.Context, imageParameter io.ReadCloser) (result AreaOfInterestResult, err error) {
  1221  	if tracing.IsEnabled() {
  1222  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetAreaOfInterestInStream")
  1223  		defer func() {
  1224  			sc := -1
  1225  			if result.Response.Response != nil {
  1226  				sc = result.Response.Response.StatusCode
  1227  			}
  1228  			tracing.EndSpan(ctx, sc, err)
  1229  		}()
  1230  	}
  1231  	req, err := client.GetAreaOfInterestInStreamPreparer(ctx, imageParameter)
  1232  	if err != nil {
  1233  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetAreaOfInterestInStream", nil, "Failure preparing request")
  1234  		return
  1235  	}
  1236  
  1237  	resp, err := client.GetAreaOfInterestInStreamSender(req)
  1238  	if err != nil {
  1239  		result.Response = autorest.Response{Response: resp}
  1240  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetAreaOfInterestInStream", resp, "Failure sending request")
  1241  		return
  1242  	}
  1243  
  1244  	result, err = client.GetAreaOfInterestInStreamResponder(resp)
  1245  	if err != nil {
  1246  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetAreaOfInterestInStream", resp, "Failure responding to request")
  1247  		return
  1248  	}
  1249  
  1250  	return
  1251  }
  1252  
  1253  // GetAreaOfInterestInStreamPreparer prepares the GetAreaOfInterestInStream request.
  1254  func (client BaseClient) GetAreaOfInterestInStreamPreparer(ctx context.Context, imageParameter io.ReadCloser) (*http.Request, error) {
  1255  	urlParameters := map[string]interface{}{
  1256  		"Endpoint": client.Endpoint,
  1257  	}
  1258  
  1259  	preparer := autorest.CreatePreparer(
  1260  		autorest.AsContentType("application/octet-stream"),
  1261  		autorest.AsPost(),
  1262  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1263  		autorest.WithPath("/areaOfInterest"),
  1264  		autorest.WithFile(imageParameter))
  1265  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1266  }
  1267  
  1268  // GetAreaOfInterestInStreamSender sends the GetAreaOfInterestInStream request. The method will close the
  1269  // http.Response Body if it receives an error.
  1270  func (client BaseClient) GetAreaOfInterestInStreamSender(req *http.Request) (*http.Response, error) {
  1271  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1272  }
  1273  
  1274  // GetAreaOfInterestInStreamResponder handles the response to the GetAreaOfInterestInStream request. The method always
  1275  // closes the http.Response Body.
  1276  func (client BaseClient) GetAreaOfInterestInStreamResponder(resp *http.Response) (result AreaOfInterestResult, err error) {
  1277  	err = autorest.Respond(
  1278  		resp,
  1279  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1280  		autorest.ByUnmarshallingJSON(&result),
  1281  		autorest.ByClosing())
  1282  	result.Response = autorest.Response{Response: resp}
  1283  	return
  1284  }
  1285  
  1286  // GetReadOperationResult this interface is used for getting OCR results of Read operation. The URL to this interface
  1287  // should be retrieved from 'Operation-Location' field returned from Batch Read File interface.
  1288  // Parameters:
  1289  // operationID - id of read operation returned in the response of the 'Batch Read File' interface.
  1290  func (client BaseClient) GetReadOperationResult(ctx context.Context, operationID string) (result ReadOperationResult, err error) {
  1291  	if tracing.IsEnabled() {
  1292  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetReadOperationResult")
  1293  		defer func() {
  1294  			sc := -1
  1295  			if result.Response.Response != nil {
  1296  				sc = result.Response.Response.StatusCode
  1297  			}
  1298  			tracing.EndSpan(ctx, sc, err)
  1299  		}()
  1300  	}
  1301  	req, err := client.GetReadOperationResultPreparer(ctx, operationID)
  1302  	if err != nil {
  1303  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetReadOperationResult", nil, "Failure preparing request")
  1304  		return
  1305  	}
  1306  
  1307  	resp, err := client.GetReadOperationResultSender(req)
  1308  	if err != nil {
  1309  		result.Response = autorest.Response{Response: resp}
  1310  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetReadOperationResult", resp, "Failure sending request")
  1311  		return
  1312  	}
  1313  
  1314  	result, err = client.GetReadOperationResultResponder(resp)
  1315  	if err != nil {
  1316  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetReadOperationResult", resp, "Failure responding to request")
  1317  		return
  1318  	}
  1319  
  1320  	return
  1321  }
  1322  
  1323  // GetReadOperationResultPreparer prepares the GetReadOperationResult request.
  1324  func (client BaseClient) GetReadOperationResultPreparer(ctx context.Context, operationID string) (*http.Request, error) {
  1325  	urlParameters := map[string]interface{}{
  1326  		"Endpoint": client.Endpoint,
  1327  	}
  1328  
  1329  	pathParameters := map[string]interface{}{
  1330  		"operationId": autorest.Encode("path", operationID),
  1331  	}
  1332  
  1333  	preparer := autorest.CreatePreparer(
  1334  		autorest.AsGet(),
  1335  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1336  		autorest.WithPathParameters("/read/operations/{operationId}", pathParameters))
  1337  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1338  }
  1339  
  1340  // GetReadOperationResultSender sends the GetReadOperationResult request. The method will close the
  1341  // http.Response Body if it receives an error.
  1342  func (client BaseClient) GetReadOperationResultSender(req *http.Request) (*http.Response, error) {
  1343  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1344  }
  1345  
  1346  // GetReadOperationResultResponder handles the response to the GetReadOperationResult request. The method always
  1347  // closes the http.Response Body.
  1348  func (client BaseClient) GetReadOperationResultResponder(resp *http.Response) (result ReadOperationResult, err error) {
  1349  	err = autorest.Respond(
  1350  		resp,
  1351  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1352  		autorest.ByUnmarshallingJSON(&result),
  1353  		autorest.ByClosing())
  1354  	result.Response = autorest.Response{Response: resp}
  1355  	return
  1356  }
  1357  
  1358  // GetTextOperationResult this interface is used for getting text operation result. The URL to this interface should be
  1359  // retrieved from 'Operation-Location' field returned from Recognize Text interface.
  1360  // Parameters:
  1361  // operationID - id of the text operation returned in the response of the 'Recognize Text'
  1362  func (client BaseClient) GetTextOperationResult(ctx context.Context, operationID string) (result TextOperationResult, err error) {
  1363  	if tracing.IsEnabled() {
  1364  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTextOperationResult")
  1365  		defer func() {
  1366  			sc := -1
  1367  			if result.Response.Response != nil {
  1368  				sc = result.Response.Response.StatusCode
  1369  			}
  1370  			tracing.EndSpan(ctx, sc, err)
  1371  		}()
  1372  	}
  1373  	req, err := client.GetTextOperationResultPreparer(ctx, operationID)
  1374  	if err != nil {
  1375  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetTextOperationResult", nil, "Failure preparing request")
  1376  		return
  1377  	}
  1378  
  1379  	resp, err := client.GetTextOperationResultSender(req)
  1380  	if err != nil {
  1381  		result.Response = autorest.Response{Response: resp}
  1382  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetTextOperationResult", resp, "Failure sending request")
  1383  		return
  1384  	}
  1385  
  1386  	result, err = client.GetTextOperationResultResponder(resp)
  1387  	if err != nil {
  1388  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "GetTextOperationResult", resp, "Failure responding to request")
  1389  		return
  1390  	}
  1391  
  1392  	return
  1393  }
  1394  
  1395  // GetTextOperationResultPreparer prepares the GetTextOperationResult request.
  1396  func (client BaseClient) GetTextOperationResultPreparer(ctx context.Context, operationID string) (*http.Request, error) {
  1397  	urlParameters := map[string]interface{}{
  1398  		"Endpoint": client.Endpoint,
  1399  	}
  1400  
  1401  	pathParameters := map[string]interface{}{
  1402  		"operationId": autorest.Encode("path", operationID),
  1403  	}
  1404  
  1405  	preparer := autorest.CreatePreparer(
  1406  		autorest.AsGet(),
  1407  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1408  		autorest.WithPathParameters("/textOperations/{operationId}", pathParameters))
  1409  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1410  }
  1411  
  1412  // GetTextOperationResultSender sends the GetTextOperationResult request. The method will close the
  1413  // http.Response Body if it receives an error.
  1414  func (client BaseClient) GetTextOperationResultSender(req *http.Request) (*http.Response, error) {
  1415  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1416  }
  1417  
  1418  // GetTextOperationResultResponder handles the response to the GetTextOperationResult request. The method always
  1419  // closes the http.Response Body.
  1420  func (client BaseClient) GetTextOperationResultResponder(resp *http.Response) (result TextOperationResult, err error) {
  1421  	err = autorest.Respond(
  1422  		resp,
  1423  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1424  		autorest.ByUnmarshallingJSON(&result),
  1425  		autorest.ByClosing())
  1426  	result.Response = autorest.Response{Response: resp}
  1427  	return
  1428  }
  1429  
  1430  // ListModels this operation returns the list of domain-specific models that are supported by the Computer Vision API.
  1431  // Currently, the API supports following domain-specific models: celebrity recognizer, landmark recognizer.
  1432  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
  1433  // message to help understand what went wrong.
  1434  func (client BaseClient) ListModels(ctx context.Context) (result ListModelsResult, err error) {
  1435  	if tracing.IsEnabled() {
  1436  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.ListModels")
  1437  		defer func() {
  1438  			sc := -1
  1439  			if result.Response.Response != nil {
  1440  				sc = result.Response.Response.StatusCode
  1441  			}
  1442  			tracing.EndSpan(ctx, sc, err)
  1443  		}()
  1444  	}
  1445  	req, err := client.ListModelsPreparer(ctx)
  1446  	if err != nil {
  1447  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "ListModels", nil, "Failure preparing request")
  1448  		return
  1449  	}
  1450  
  1451  	resp, err := client.ListModelsSender(req)
  1452  	if err != nil {
  1453  		result.Response = autorest.Response{Response: resp}
  1454  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "ListModels", resp, "Failure sending request")
  1455  		return
  1456  	}
  1457  
  1458  	result, err = client.ListModelsResponder(resp)
  1459  	if err != nil {
  1460  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "ListModels", resp, "Failure responding to request")
  1461  		return
  1462  	}
  1463  
  1464  	return
  1465  }
  1466  
  1467  // ListModelsPreparer prepares the ListModels request.
  1468  func (client BaseClient) ListModelsPreparer(ctx context.Context) (*http.Request, error) {
  1469  	urlParameters := map[string]interface{}{
  1470  		"Endpoint": client.Endpoint,
  1471  	}
  1472  
  1473  	preparer := autorest.CreatePreparer(
  1474  		autorest.AsGet(),
  1475  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1476  		autorest.WithPath("/models"))
  1477  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1478  }
  1479  
  1480  // ListModelsSender sends the ListModels request. The method will close the
  1481  // http.Response Body if it receives an error.
  1482  func (client BaseClient) ListModelsSender(req *http.Request) (*http.Response, error) {
  1483  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1484  }
  1485  
  1486  // ListModelsResponder handles the response to the ListModels request. The method always
  1487  // closes the http.Response Body.
  1488  func (client BaseClient) ListModelsResponder(resp *http.Response) (result ListModelsResult, err error) {
  1489  	err = autorest.Respond(
  1490  		resp,
  1491  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1492  		autorest.ByUnmarshallingJSON(&result),
  1493  		autorest.ByClosing())
  1494  	result.Response = autorest.Response{Response: resp}
  1495  	return
  1496  }
  1497  
  1498  // RecognizePrintedText optical Character Recognition (OCR) detects text in an image and extracts the recognized
  1499  // characters into a machine-usable character stream.
  1500  // Upon success, the OCR results will be returned.
  1501  // Upon failure, the error code together with an error message will be returned. The error code can be one of
  1502  // InvalidImageUrl, InvalidImageFormat, InvalidImageSize, NotSupportedImage, NotSupportedLanguage, or
  1503  // InternalServerError.
  1504  // Parameters:
  1505  // detectOrientation - whether detect the text orientation in the image. With detectOrientation=true the OCR
  1506  // service tries to detect the image orientation and correct it before further processing (e.g. if it's
  1507  // upside-down).
  1508  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
  1509  // language - the BCP-47 language code of the text to be detected in the image. The default value is 'unk'.
  1510  func (client BaseClient) RecognizePrintedText(ctx context.Context, detectOrientation bool, imageURL ImageURL, language OcrLanguages) (result OcrResult, err error) {
  1511  	if tracing.IsEnabled() {
  1512  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.RecognizePrintedText")
  1513  		defer func() {
  1514  			sc := -1
  1515  			if result.Response.Response != nil {
  1516  				sc = result.Response.Response.StatusCode
  1517  			}
  1518  			tracing.EndSpan(ctx, sc, err)
  1519  		}()
  1520  	}
  1521  	if err := validation.Validate([]validation.Validation{
  1522  		{TargetValue: imageURL,
  1523  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1524  		return result, validation.NewError("computervision.BaseClient", "RecognizePrintedText", err.Error())
  1525  	}
  1526  
  1527  	req, err := client.RecognizePrintedTextPreparer(ctx, detectOrientation, imageURL, language)
  1528  	if err != nil {
  1529  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizePrintedText", nil, "Failure preparing request")
  1530  		return
  1531  	}
  1532  
  1533  	resp, err := client.RecognizePrintedTextSender(req)
  1534  	if err != nil {
  1535  		result.Response = autorest.Response{Response: resp}
  1536  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizePrintedText", resp, "Failure sending request")
  1537  		return
  1538  	}
  1539  
  1540  	result, err = client.RecognizePrintedTextResponder(resp)
  1541  	if err != nil {
  1542  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizePrintedText", resp, "Failure responding to request")
  1543  		return
  1544  	}
  1545  
  1546  	return
  1547  }
  1548  
  1549  // RecognizePrintedTextPreparer prepares the RecognizePrintedText request.
  1550  func (client BaseClient) RecognizePrintedTextPreparer(ctx context.Context, detectOrientation bool, imageURL ImageURL, language OcrLanguages) (*http.Request, error) {
  1551  	urlParameters := map[string]interface{}{
  1552  		"Endpoint": client.Endpoint,
  1553  	}
  1554  
  1555  	queryParameters := map[string]interface{}{
  1556  		"detectOrientation": autorest.Encode("query", detectOrientation),
  1557  	}
  1558  	if len(string(language)) > 0 {
  1559  		queryParameters["language"] = autorest.Encode("query", language)
  1560  	} else {
  1561  		queryParameters["language"] = autorest.Encode("query", "unk")
  1562  	}
  1563  
  1564  	preparer := autorest.CreatePreparer(
  1565  		autorest.AsContentType("application/json; charset=utf-8"),
  1566  		autorest.AsPost(),
  1567  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1568  		autorest.WithPath("/ocr"),
  1569  		autorest.WithJSON(imageURL),
  1570  		autorest.WithQueryParameters(queryParameters))
  1571  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1572  }
  1573  
  1574  // RecognizePrintedTextSender sends the RecognizePrintedText request. The method will close the
  1575  // http.Response Body if it receives an error.
  1576  func (client BaseClient) RecognizePrintedTextSender(req *http.Request) (*http.Response, error) {
  1577  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1578  }
  1579  
  1580  // RecognizePrintedTextResponder handles the response to the RecognizePrintedText request. The method always
  1581  // closes the http.Response Body.
  1582  func (client BaseClient) RecognizePrintedTextResponder(resp *http.Response) (result OcrResult, err error) {
  1583  	err = autorest.Respond(
  1584  		resp,
  1585  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1586  		autorest.ByUnmarshallingJSON(&result),
  1587  		autorest.ByClosing())
  1588  	result.Response = autorest.Response{Response: resp}
  1589  	return
  1590  }
  1591  
  1592  // RecognizePrintedTextInStream optical Character Recognition (OCR) detects text in an image and extracts the
  1593  // recognized characters into a machine-usable character stream.
  1594  // Upon success, the OCR results will be returned.
  1595  // Upon failure, the error code together with an error message will be returned. The error code can be one of
  1596  // InvalidImageUrl, InvalidImageFormat, InvalidImageSize, NotSupportedImage, NotSupportedLanguage, or
  1597  // InternalServerError.
  1598  // Parameters:
  1599  // detectOrientation - whether detect the text orientation in the image. With detectOrientation=true the OCR
  1600  // service tries to detect the image orientation and correct it before further processing (e.g. if it's
  1601  // upside-down).
  1602  // imageParameter - an image stream.
  1603  // language - the BCP-47 language code of the text to be detected in the image. The default value is 'unk'.
  1604  func (client BaseClient) RecognizePrintedTextInStream(ctx context.Context, detectOrientation bool, imageParameter io.ReadCloser, language OcrLanguages) (result OcrResult, err error) {
  1605  	if tracing.IsEnabled() {
  1606  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.RecognizePrintedTextInStream")
  1607  		defer func() {
  1608  			sc := -1
  1609  			if result.Response.Response != nil {
  1610  				sc = result.Response.Response.StatusCode
  1611  			}
  1612  			tracing.EndSpan(ctx, sc, err)
  1613  		}()
  1614  	}
  1615  	req, err := client.RecognizePrintedTextInStreamPreparer(ctx, detectOrientation, imageParameter, language)
  1616  	if err != nil {
  1617  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizePrintedTextInStream", nil, "Failure preparing request")
  1618  		return
  1619  	}
  1620  
  1621  	resp, err := client.RecognizePrintedTextInStreamSender(req)
  1622  	if err != nil {
  1623  		result.Response = autorest.Response{Response: resp}
  1624  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizePrintedTextInStream", resp, "Failure sending request")
  1625  		return
  1626  	}
  1627  
  1628  	result, err = client.RecognizePrintedTextInStreamResponder(resp)
  1629  	if err != nil {
  1630  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizePrintedTextInStream", resp, "Failure responding to request")
  1631  		return
  1632  	}
  1633  
  1634  	return
  1635  }
  1636  
  1637  // RecognizePrintedTextInStreamPreparer prepares the RecognizePrintedTextInStream request.
  1638  func (client BaseClient) RecognizePrintedTextInStreamPreparer(ctx context.Context, detectOrientation bool, imageParameter io.ReadCloser, language OcrLanguages) (*http.Request, error) {
  1639  	urlParameters := map[string]interface{}{
  1640  		"Endpoint": client.Endpoint,
  1641  	}
  1642  
  1643  	queryParameters := map[string]interface{}{
  1644  		"detectOrientation": autorest.Encode("query", detectOrientation),
  1645  	}
  1646  	if len(string(language)) > 0 {
  1647  		queryParameters["language"] = autorest.Encode("query", language)
  1648  	} else {
  1649  		queryParameters["language"] = autorest.Encode("query", "unk")
  1650  	}
  1651  
  1652  	preparer := autorest.CreatePreparer(
  1653  		autorest.AsContentType("application/octet-stream"),
  1654  		autorest.AsPost(),
  1655  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1656  		autorest.WithPath("/ocr"),
  1657  		autorest.WithFile(imageParameter),
  1658  		autorest.WithQueryParameters(queryParameters))
  1659  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1660  }
  1661  
  1662  // RecognizePrintedTextInStreamSender sends the RecognizePrintedTextInStream request. The method will close the
  1663  // http.Response Body if it receives an error.
  1664  func (client BaseClient) RecognizePrintedTextInStreamSender(req *http.Request) (*http.Response, error) {
  1665  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1666  }
  1667  
  1668  // RecognizePrintedTextInStreamResponder handles the response to the RecognizePrintedTextInStream request. The method always
  1669  // closes the http.Response Body.
  1670  func (client BaseClient) RecognizePrintedTextInStreamResponder(resp *http.Response) (result OcrResult, err error) {
  1671  	err = autorest.Respond(
  1672  		resp,
  1673  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1674  		autorest.ByUnmarshallingJSON(&result),
  1675  		autorest.ByClosing())
  1676  	result.Response = autorest.Response{Response: resp}
  1677  	return
  1678  }
  1679  
  1680  // RecognizeText recognize Text operation. When you use the Recognize Text interface, the response contains a field
  1681  // called 'Operation-Location'. The 'Operation-Location' field contains the URL that you must use for your Get
  1682  // Recognize Text Operation Result operation.
  1683  // Parameters:
  1684  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
  1685  // mode - type of text to recognize.
  1686  func (client BaseClient) RecognizeText(ctx context.Context, imageURL ImageURL, mode TextRecognitionMode) (result autorest.Response, err error) {
  1687  	if tracing.IsEnabled() {
  1688  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.RecognizeText")
  1689  		defer func() {
  1690  			sc := -1
  1691  			if result.Response != nil {
  1692  				sc = result.Response.StatusCode
  1693  			}
  1694  			tracing.EndSpan(ctx, sc, err)
  1695  		}()
  1696  	}
  1697  	if err := validation.Validate([]validation.Validation{
  1698  		{TargetValue: imageURL,
  1699  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1700  		return result, validation.NewError("computervision.BaseClient", "RecognizeText", err.Error())
  1701  	}
  1702  
  1703  	req, err := client.RecognizeTextPreparer(ctx, imageURL, mode)
  1704  	if err != nil {
  1705  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizeText", nil, "Failure preparing request")
  1706  		return
  1707  	}
  1708  
  1709  	resp, err := client.RecognizeTextSender(req)
  1710  	if err != nil {
  1711  		result.Response = resp
  1712  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizeText", resp, "Failure sending request")
  1713  		return
  1714  	}
  1715  
  1716  	result, err = client.RecognizeTextResponder(resp)
  1717  	if err != nil {
  1718  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizeText", resp, "Failure responding to request")
  1719  		return
  1720  	}
  1721  
  1722  	return
  1723  }
  1724  
  1725  // RecognizeTextPreparer prepares the RecognizeText request.
  1726  func (client BaseClient) RecognizeTextPreparer(ctx context.Context, imageURL ImageURL, mode TextRecognitionMode) (*http.Request, error) {
  1727  	urlParameters := map[string]interface{}{
  1728  		"Endpoint": client.Endpoint,
  1729  	}
  1730  
  1731  	queryParameters := map[string]interface{}{
  1732  		"mode": autorest.Encode("query", mode),
  1733  	}
  1734  
  1735  	preparer := autorest.CreatePreparer(
  1736  		autorest.AsContentType("application/json; charset=utf-8"),
  1737  		autorest.AsPost(),
  1738  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1739  		autorest.WithPath("/recognizeText"),
  1740  		autorest.WithJSON(imageURL),
  1741  		autorest.WithQueryParameters(queryParameters))
  1742  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1743  }
  1744  
  1745  // RecognizeTextSender sends the RecognizeText request. The method will close the
  1746  // http.Response Body if it receives an error.
  1747  func (client BaseClient) RecognizeTextSender(req *http.Request) (*http.Response, error) {
  1748  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1749  }
  1750  
  1751  // RecognizeTextResponder handles the response to the RecognizeText request. The method always
  1752  // closes the http.Response Body.
  1753  func (client BaseClient) RecognizeTextResponder(resp *http.Response) (result autorest.Response, err error) {
  1754  	err = autorest.Respond(
  1755  		resp,
  1756  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1757  		autorest.ByClosing())
  1758  	result.Response = resp
  1759  	return
  1760  }
  1761  
  1762  // RecognizeTextInStream recognize Text operation. When you use the Recognize Text interface, the response contains a
  1763  // field called 'Operation-Location'. The 'Operation-Location' field contains the URL that you must use for your Get
  1764  // Recognize Text Operation Result operation.
  1765  // Parameters:
  1766  // imageParameter - an image stream.
  1767  // mode - type of text to recognize.
  1768  func (client BaseClient) RecognizeTextInStream(ctx context.Context, imageParameter io.ReadCloser, mode TextRecognitionMode) (result autorest.Response, err error) {
  1769  	if tracing.IsEnabled() {
  1770  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.RecognizeTextInStream")
  1771  		defer func() {
  1772  			sc := -1
  1773  			if result.Response != nil {
  1774  				sc = result.Response.StatusCode
  1775  			}
  1776  			tracing.EndSpan(ctx, sc, err)
  1777  		}()
  1778  	}
  1779  	req, err := client.RecognizeTextInStreamPreparer(ctx, imageParameter, mode)
  1780  	if err != nil {
  1781  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizeTextInStream", nil, "Failure preparing request")
  1782  		return
  1783  	}
  1784  
  1785  	resp, err := client.RecognizeTextInStreamSender(req)
  1786  	if err != nil {
  1787  		result.Response = resp
  1788  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizeTextInStream", resp, "Failure sending request")
  1789  		return
  1790  	}
  1791  
  1792  	result, err = client.RecognizeTextInStreamResponder(resp)
  1793  	if err != nil {
  1794  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "RecognizeTextInStream", resp, "Failure responding to request")
  1795  		return
  1796  	}
  1797  
  1798  	return
  1799  }
  1800  
  1801  // RecognizeTextInStreamPreparer prepares the RecognizeTextInStream request.
  1802  func (client BaseClient) RecognizeTextInStreamPreparer(ctx context.Context, imageParameter io.ReadCloser, mode TextRecognitionMode) (*http.Request, error) {
  1803  	urlParameters := map[string]interface{}{
  1804  		"Endpoint": client.Endpoint,
  1805  	}
  1806  
  1807  	queryParameters := map[string]interface{}{
  1808  		"mode": autorest.Encode("query", mode),
  1809  	}
  1810  
  1811  	preparer := autorest.CreatePreparer(
  1812  		autorest.AsContentType("application/octet-stream"),
  1813  		autorest.AsPost(),
  1814  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1815  		autorest.WithPath("/recognizeText"),
  1816  		autorest.WithFile(imageParameter),
  1817  		autorest.WithQueryParameters(queryParameters))
  1818  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1819  }
  1820  
  1821  // RecognizeTextInStreamSender sends the RecognizeTextInStream request. The method will close the
  1822  // http.Response Body if it receives an error.
  1823  func (client BaseClient) RecognizeTextInStreamSender(req *http.Request) (*http.Response, error) {
  1824  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1825  }
  1826  
  1827  // RecognizeTextInStreamResponder handles the response to the RecognizeTextInStream request. The method always
  1828  // closes the http.Response Body.
  1829  func (client BaseClient) RecognizeTextInStreamResponder(resp *http.Response) (result autorest.Response, err error) {
  1830  	err = autorest.Respond(
  1831  		resp,
  1832  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1833  		autorest.ByClosing())
  1834  	result.Response = resp
  1835  	return
  1836  }
  1837  
  1838  // TagImage this operation generates a list of words, or tags, that are relevant to the content of the supplied image.
  1839  // The Computer Vision API can return tags based on objects, living beings, scenery or actions found in images. Unlike
  1840  // categories, tags are not organized according to a hierarchical classification system, but correspond to image
  1841  // content. Tags may contain hints to avoid ambiguity or provide context, for example the tag "cello" may be
  1842  // accompanied by the hint "musical instrument". All tags are in English.
  1843  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
  1844  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
  1845  // message to help understand what went wrong.
  1846  // Parameters:
  1847  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
  1848  // language - the desired language for output generation. If this parameter is not specified, the default value
  1849  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
  1850  // zh - Simplified Chinese.
  1851  func (client BaseClient) TagImage(ctx context.Context, imageURL ImageURL, language string) (result TagResult, err error) {
  1852  	if tracing.IsEnabled() {
  1853  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.TagImage")
  1854  		defer func() {
  1855  			sc := -1
  1856  			if result.Response.Response != nil {
  1857  				sc = result.Response.Response.StatusCode
  1858  			}
  1859  			tracing.EndSpan(ctx, sc, err)
  1860  		}()
  1861  	}
  1862  	if err := validation.Validate([]validation.Validation{
  1863  		{TargetValue: imageURL,
  1864  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1865  		return result, validation.NewError("computervision.BaseClient", "TagImage", err.Error())
  1866  	}
  1867  
  1868  	req, err := client.TagImagePreparer(ctx, imageURL, language)
  1869  	if err != nil {
  1870  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "TagImage", nil, "Failure preparing request")
  1871  		return
  1872  	}
  1873  
  1874  	resp, err := client.TagImageSender(req)
  1875  	if err != nil {
  1876  		result.Response = autorest.Response{Response: resp}
  1877  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "TagImage", resp, "Failure sending request")
  1878  		return
  1879  	}
  1880  
  1881  	result, err = client.TagImageResponder(resp)
  1882  	if err != nil {
  1883  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "TagImage", resp, "Failure responding to request")
  1884  		return
  1885  	}
  1886  
  1887  	return
  1888  }
  1889  
  1890  // TagImagePreparer prepares the TagImage request.
  1891  func (client BaseClient) TagImagePreparer(ctx context.Context, imageURL ImageURL, language string) (*http.Request, error) {
  1892  	urlParameters := map[string]interface{}{
  1893  		"Endpoint": client.Endpoint,
  1894  	}
  1895  
  1896  	queryParameters := map[string]interface{}{}
  1897  	if len(string(language)) > 0 {
  1898  		queryParameters["language"] = autorest.Encode("query", language)
  1899  	} else {
  1900  		queryParameters["language"] = autorest.Encode("query", "en")
  1901  	}
  1902  
  1903  	preparer := autorest.CreatePreparer(
  1904  		autorest.AsContentType("application/json; charset=utf-8"),
  1905  		autorest.AsPost(),
  1906  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1907  		autorest.WithPath("/tag"),
  1908  		autorest.WithJSON(imageURL),
  1909  		autorest.WithQueryParameters(queryParameters))
  1910  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1911  }
  1912  
  1913  // TagImageSender sends the TagImage request. The method will close the
  1914  // http.Response Body if it receives an error.
  1915  func (client BaseClient) TagImageSender(req *http.Request) (*http.Response, error) {
  1916  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1917  }
  1918  
  1919  // TagImageResponder handles the response to the TagImage request. The method always
  1920  // closes the http.Response Body.
  1921  func (client BaseClient) TagImageResponder(resp *http.Response) (result TagResult, err error) {
  1922  	err = autorest.Respond(
  1923  		resp,
  1924  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1925  		autorest.ByUnmarshallingJSON(&result),
  1926  		autorest.ByClosing())
  1927  	result.Response = autorest.Response{Response: resp}
  1928  	return
  1929  }
  1930  
  1931  // TagImageInStream this operation generates a list of words, or tags, that are relevant to the content of the supplied
  1932  // image. The Computer Vision API can return tags based on objects, living beings, scenery or actions found in images.
  1933  // Unlike categories, tags are not organized according to a hierarchical classification system, but correspond to image
  1934  // content. Tags may contain hints to avoid ambiguity or provide context, for example the tag "cello" may be
  1935  // accompanied by the hint "musical instrument". All tags are in English.
  1936  // Two input methods are supported -- (1) Uploading an image or (2) specifying an image URL.
  1937  // A successful response will be returned in JSON. If the request failed, the response will contain an error code and a
  1938  // message to help understand what went wrong.
  1939  // Parameters:
  1940  // imageParameter - an image stream.
  1941  // language - the desired language for output generation. If this parameter is not specified, the default value
  1942  // is "en".Supported languages:en - English, Default. es - Spanish, ja - Japanese, pt - Portuguese,
  1943  // zh - Simplified Chinese.
  1944  func (client BaseClient) TagImageInStream(ctx context.Context, imageParameter io.ReadCloser, language string) (result TagResult, err error) {
  1945  	if tracing.IsEnabled() {
  1946  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.TagImageInStream")
  1947  		defer func() {
  1948  			sc := -1
  1949  			if result.Response.Response != nil {
  1950  				sc = result.Response.Response.StatusCode
  1951  			}
  1952  			tracing.EndSpan(ctx, sc, err)
  1953  		}()
  1954  	}
  1955  	req, err := client.TagImageInStreamPreparer(ctx, imageParameter, language)
  1956  	if err != nil {
  1957  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "TagImageInStream", nil, "Failure preparing request")
  1958  		return
  1959  	}
  1960  
  1961  	resp, err := client.TagImageInStreamSender(req)
  1962  	if err != nil {
  1963  		result.Response = autorest.Response{Response: resp}
  1964  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "TagImageInStream", resp, "Failure sending request")
  1965  		return
  1966  	}
  1967  
  1968  	result, err = client.TagImageInStreamResponder(resp)
  1969  	if err != nil {
  1970  		err = autorest.NewErrorWithError(err, "computervision.BaseClient", "TagImageInStream", resp, "Failure responding to request")
  1971  		return
  1972  	}
  1973  
  1974  	return
  1975  }
  1976  
  1977  // TagImageInStreamPreparer prepares the TagImageInStream request.
  1978  func (client BaseClient) TagImageInStreamPreparer(ctx context.Context, imageParameter io.ReadCloser, language string) (*http.Request, error) {
  1979  	urlParameters := map[string]interface{}{
  1980  		"Endpoint": client.Endpoint,
  1981  	}
  1982  
  1983  	queryParameters := map[string]interface{}{}
  1984  	if len(string(language)) > 0 {
  1985  		queryParameters["language"] = autorest.Encode("query", language)
  1986  	} else {
  1987  		queryParameters["language"] = autorest.Encode("query", "en")
  1988  	}
  1989  
  1990  	preparer := autorest.CreatePreparer(
  1991  		autorest.AsContentType("application/octet-stream"),
  1992  		autorest.AsPost(),
  1993  		autorest.WithCustomBaseURL("{Endpoint}/vision/v2.0", urlParameters),
  1994  		autorest.WithPath("/tag"),
  1995  		autorest.WithFile(imageParameter),
  1996  		autorest.WithQueryParameters(queryParameters))
  1997  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1998  }
  1999  
  2000  // TagImageInStreamSender sends the TagImageInStream request. The method will close the
  2001  // http.Response Body if it receives an error.
  2002  func (client BaseClient) TagImageInStreamSender(req *http.Request) (*http.Response, error) {
  2003  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2004  }
  2005  
  2006  // TagImageInStreamResponder handles the response to the TagImageInStream request. The method always
  2007  // closes the http.Response Body.
  2008  func (client BaseClient) TagImageInStreamResponder(resp *http.Response) (result TagResult, err error) {
  2009  	err = autorest.Respond(
  2010  		resp,
  2011  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2012  		autorest.ByUnmarshallingJSON(&result),
  2013  		autorest.ByClosing())
  2014  	result.Response = autorest.Response{Response: resp}
  2015  	return
  2016  }
  2017  

View as plain text