Source file src/github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.2/customvision/training/client.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.2/customvision/training

     1  // Package training implements the Azure ARM Training service API version 2.2.
     2  //
     3  //
     4  package training
     5  
     6  // Copyright (c) Microsoft Corporation. All rights reserved.
     7  // Licensed under the MIT License. See License.txt in the project root for license information.
     8  //
     9  // Code generated by Microsoft (R) AutoRest Code Generator.
    10  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
    11  
    12  import (
    13  	"context"
    14  	"github.com/Azure/go-autorest/autorest"
    15  	"github.com/Azure/go-autorest/autorest/azure"
    16  	"github.com/Azure/go-autorest/autorest/validation"
    17  	"github.com/Azure/go-autorest/tracing"
    18  	"github.com/gofrs/uuid"
    19  	"io"
    20  	"net/http"
    21  )
    22  
    23  // BaseClient is the base client for Training.
    24  type BaseClient struct {
    25  	autorest.Client
    26  	APIKey   string
    27  	Endpoint string
    28  }
    29  
    30  // New creates an instance of the BaseClient client.
    31  func New(aPIKey string, endpoint string) BaseClient {
    32  	return NewWithoutDefaults(aPIKey, endpoint)
    33  }
    34  
    35  // NewWithoutDefaults creates an instance of the BaseClient client.
    36  func NewWithoutDefaults(aPIKey string, endpoint string) BaseClient {
    37  	return BaseClient{
    38  		Client:   autorest.NewClientWithUserAgent(UserAgent()),
    39  		APIKey:   aPIKey,
    40  		Endpoint: endpoint,
    41  	}
    42  }
    43  
    44  // CreateImageRegions this API accepts a batch of image regions, and optionally tags, to update existing images with
    45  // region information.
    46  // There is a limit of 64 entries in the batch.
    47  // Parameters:
    48  // projectID - the project id.
    49  // batch - batch of image regions which include a tag and bounding box. Limited to 64.
    50  func (client BaseClient) CreateImageRegions(ctx context.Context, projectID uuid.UUID, batch ImageRegionCreateBatch) (result ImageRegionCreateSummary, err error) {
    51  	if tracing.IsEnabled() {
    52  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImageRegions")
    53  		defer func() {
    54  			sc := -1
    55  			if result.Response.Response != nil {
    56  				sc = result.Response.Response.StatusCode
    57  			}
    58  			tracing.EndSpan(ctx, sc, err)
    59  		}()
    60  	}
    61  	req, err := client.CreateImageRegionsPreparer(ctx, projectID, batch)
    62  	if err != nil {
    63  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageRegions", nil, "Failure preparing request")
    64  		return
    65  	}
    66  
    67  	resp, err := client.CreateImageRegionsSender(req)
    68  	if err != nil {
    69  		result.Response = autorest.Response{Response: resp}
    70  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageRegions", resp, "Failure sending request")
    71  		return
    72  	}
    73  
    74  	result, err = client.CreateImageRegionsResponder(resp)
    75  	if err != nil {
    76  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageRegions", resp, "Failure responding to request")
    77  		return
    78  	}
    79  
    80  	return
    81  }
    82  
    83  // CreateImageRegionsPreparer prepares the CreateImageRegions request.
    84  func (client BaseClient) CreateImageRegionsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageRegionCreateBatch) (*http.Request, error) {
    85  	urlParameters := map[string]interface{}{
    86  		"Endpoint": client.Endpoint,
    87  	}
    88  
    89  	pathParameters := map[string]interface{}{
    90  		"projectId": autorest.Encode("path", projectID),
    91  	}
    92  
    93  	preparer := autorest.CreatePreparer(
    94  		autorest.AsContentType("application/json; charset=utf-8"),
    95  		autorest.AsPost(),
    96  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
    97  		autorest.WithPathParameters("/projects/{projectId}/images/regions", pathParameters),
    98  		autorest.WithJSON(batch),
    99  		autorest.WithHeader("Training-Key", client.APIKey))
   100  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   101  }
   102  
   103  // CreateImageRegionsSender sends the CreateImageRegions request. The method will close the
   104  // http.Response Body if it receives an error.
   105  func (client BaseClient) CreateImageRegionsSender(req *http.Request) (*http.Response, error) {
   106  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   107  }
   108  
   109  // CreateImageRegionsResponder handles the response to the CreateImageRegions request. The method always
   110  // closes the http.Response Body.
   111  func (client BaseClient) CreateImageRegionsResponder(resp *http.Response) (result ImageRegionCreateSummary, err error) {
   112  	err = autorest.Respond(
   113  		resp,
   114  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   115  		autorest.ByUnmarshallingJSON(&result),
   116  		autorest.ByClosing())
   117  	result.Response = autorest.Response{Response: resp}
   118  	return
   119  }
   120  
   121  // CreateImagesFromData this API accepts body content as multipart/form-data and application/octet-stream. When using
   122  // multipart
   123  // multiple image files can be sent at once, with a maximum of 64 files
   124  // Parameters:
   125  // projectID - the project id.
   126  // imageData - binary image data.
   127  // tagIds - the tags ids with which to tag each image. Limited to 20.
   128  func (client BaseClient) CreateImagesFromData(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, tagIds []string) (result ImageCreateSummary, err error) {
   129  	if tracing.IsEnabled() {
   130  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromData")
   131  		defer func() {
   132  			sc := -1
   133  			if result.Response.Response != nil {
   134  				sc = result.Response.Response.StatusCode
   135  			}
   136  			tracing.EndSpan(ctx, sc, err)
   137  		}()
   138  	}
   139  	req, err := client.CreateImagesFromDataPreparer(ctx, projectID, imageData, tagIds)
   140  	if err != nil {
   141  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromData", nil, "Failure preparing request")
   142  		return
   143  	}
   144  
   145  	resp, err := client.CreateImagesFromDataSender(req)
   146  	if err != nil {
   147  		result.Response = autorest.Response{Response: resp}
   148  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromData", resp, "Failure sending request")
   149  		return
   150  	}
   151  
   152  	result, err = client.CreateImagesFromDataResponder(resp)
   153  	if err != nil {
   154  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromData", resp, "Failure responding to request")
   155  		return
   156  	}
   157  
   158  	return
   159  }
   160  
   161  // CreateImagesFromDataPreparer prepares the CreateImagesFromData request.
   162  func (client BaseClient) CreateImagesFromDataPreparer(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, tagIds []string) (*http.Request, error) {
   163  	urlParameters := map[string]interface{}{
   164  		"Endpoint": client.Endpoint,
   165  	}
   166  
   167  	pathParameters := map[string]interface{}{
   168  		"projectId": autorest.Encode("path", projectID),
   169  	}
   170  
   171  	queryParameters := map[string]interface{}{}
   172  	if tagIds != nil && len(tagIds) > 0 {
   173  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
   174  	}
   175  
   176  	formDataParameters := map[string]interface{}{
   177  		"imageData": imageData,
   178  	}
   179  
   180  	preparer := autorest.CreatePreparer(
   181  		autorest.AsPost(),
   182  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   183  		autorest.WithPathParameters("/projects/{projectId}/images", pathParameters),
   184  		autorest.WithQueryParameters(queryParameters),
   185  		autorest.WithMultiPartFormData(formDataParameters),
   186  		autorest.WithHeader("Training-Key", client.APIKey))
   187  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   188  }
   189  
   190  // CreateImagesFromDataSender sends the CreateImagesFromData request. The method will close the
   191  // http.Response Body if it receives an error.
   192  func (client BaseClient) CreateImagesFromDataSender(req *http.Request) (*http.Response, error) {
   193  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   194  }
   195  
   196  // CreateImagesFromDataResponder handles the response to the CreateImagesFromData request. The method always
   197  // closes the http.Response Body.
   198  func (client BaseClient) CreateImagesFromDataResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   199  	err = autorest.Respond(
   200  		resp,
   201  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   202  		autorest.ByUnmarshallingJSON(&result),
   203  		autorest.ByClosing())
   204  	result.Response = autorest.Response{Response: resp}
   205  	return
   206  }
   207  
   208  // CreateImagesFromFiles this API accepts a batch of files, and optionally tags, to create images. There is a limit of
   209  // 64 images and 20 tags.
   210  // Parameters:
   211  // projectID - the project id.
   212  // batch - the batch of image files to add. Limited to 64 images and 20 tags per batch.
   213  func (client BaseClient) CreateImagesFromFiles(ctx context.Context, projectID uuid.UUID, batch ImageFileCreateBatch) (result ImageCreateSummary, err error) {
   214  	if tracing.IsEnabled() {
   215  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromFiles")
   216  		defer func() {
   217  			sc := -1
   218  			if result.Response.Response != nil {
   219  				sc = result.Response.Response.StatusCode
   220  			}
   221  			tracing.EndSpan(ctx, sc, err)
   222  		}()
   223  	}
   224  	req, err := client.CreateImagesFromFilesPreparer(ctx, projectID, batch)
   225  	if err != nil {
   226  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromFiles", nil, "Failure preparing request")
   227  		return
   228  	}
   229  
   230  	resp, err := client.CreateImagesFromFilesSender(req)
   231  	if err != nil {
   232  		result.Response = autorest.Response{Response: resp}
   233  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromFiles", resp, "Failure sending request")
   234  		return
   235  	}
   236  
   237  	result, err = client.CreateImagesFromFilesResponder(resp)
   238  	if err != nil {
   239  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromFiles", resp, "Failure responding to request")
   240  		return
   241  	}
   242  
   243  	return
   244  }
   245  
   246  // CreateImagesFromFilesPreparer prepares the CreateImagesFromFiles request.
   247  func (client BaseClient) CreateImagesFromFilesPreparer(ctx context.Context, projectID uuid.UUID, batch ImageFileCreateBatch) (*http.Request, error) {
   248  	urlParameters := map[string]interface{}{
   249  		"Endpoint": client.Endpoint,
   250  	}
   251  
   252  	pathParameters := map[string]interface{}{
   253  		"projectId": autorest.Encode("path", projectID),
   254  	}
   255  
   256  	preparer := autorest.CreatePreparer(
   257  		autorest.AsContentType("application/json; charset=utf-8"),
   258  		autorest.AsPost(),
   259  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   260  		autorest.WithPathParameters("/projects/{projectId}/images/files", pathParameters),
   261  		autorest.WithJSON(batch),
   262  		autorest.WithHeader("Training-Key", client.APIKey))
   263  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   264  }
   265  
   266  // CreateImagesFromFilesSender sends the CreateImagesFromFiles request. The method will close the
   267  // http.Response Body if it receives an error.
   268  func (client BaseClient) CreateImagesFromFilesSender(req *http.Request) (*http.Response, error) {
   269  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   270  }
   271  
   272  // CreateImagesFromFilesResponder handles the response to the CreateImagesFromFiles request. The method always
   273  // closes the http.Response Body.
   274  func (client BaseClient) CreateImagesFromFilesResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   275  	err = autorest.Respond(
   276  		resp,
   277  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   278  		autorest.ByUnmarshallingJSON(&result),
   279  		autorest.ByClosing())
   280  	result.Response = autorest.Response{Response: resp}
   281  	return
   282  }
   283  
   284  // CreateImagesFromPredictions this API creates a batch of images from predicted images specified. There is a limit of
   285  // 64 images and 20 tags.
   286  // Parameters:
   287  // projectID - the project id.
   288  // batch - image and tag ids. Limited to 64 images and 20 tags per batch.
   289  func (client BaseClient) CreateImagesFromPredictions(ctx context.Context, projectID uuid.UUID, batch ImageIDCreateBatch) (result ImageCreateSummary, err error) {
   290  	if tracing.IsEnabled() {
   291  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromPredictions")
   292  		defer func() {
   293  			sc := -1
   294  			if result.Response.Response != nil {
   295  				sc = result.Response.Response.StatusCode
   296  			}
   297  			tracing.EndSpan(ctx, sc, err)
   298  		}()
   299  	}
   300  	req, err := client.CreateImagesFromPredictionsPreparer(ctx, projectID, batch)
   301  	if err != nil {
   302  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromPredictions", nil, "Failure preparing request")
   303  		return
   304  	}
   305  
   306  	resp, err := client.CreateImagesFromPredictionsSender(req)
   307  	if err != nil {
   308  		result.Response = autorest.Response{Response: resp}
   309  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromPredictions", resp, "Failure sending request")
   310  		return
   311  	}
   312  
   313  	result, err = client.CreateImagesFromPredictionsResponder(resp)
   314  	if err != nil {
   315  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromPredictions", resp, "Failure responding to request")
   316  		return
   317  	}
   318  
   319  	return
   320  }
   321  
   322  // CreateImagesFromPredictionsPreparer prepares the CreateImagesFromPredictions request.
   323  func (client BaseClient) CreateImagesFromPredictionsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageIDCreateBatch) (*http.Request, error) {
   324  	urlParameters := map[string]interface{}{
   325  		"Endpoint": client.Endpoint,
   326  	}
   327  
   328  	pathParameters := map[string]interface{}{
   329  		"projectId": autorest.Encode("path", projectID),
   330  	}
   331  
   332  	preparer := autorest.CreatePreparer(
   333  		autorest.AsContentType("application/json; charset=utf-8"),
   334  		autorest.AsPost(),
   335  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   336  		autorest.WithPathParameters("/projects/{projectId}/images/predictions", pathParameters),
   337  		autorest.WithJSON(batch),
   338  		autorest.WithHeader("Training-Key", client.APIKey))
   339  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   340  }
   341  
   342  // CreateImagesFromPredictionsSender sends the CreateImagesFromPredictions request. The method will close the
   343  // http.Response Body if it receives an error.
   344  func (client BaseClient) CreateImagesFromPredictionsSender(req *http.Request) (*http.Response, error) {
   345  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   346  }
   347  
   348  // CreateImagesFromPredictionsResponder handles the response to the CreateImagesFromPredictions request. The method always
   349  // closes the http.Response Body.
   350  func (client BaseClient) CreateImagesFromPredictionsResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   351  	err = autorest.Respond(
   352  		resp,
   353  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   354  		autorest.ByUnmarshallingJSON(&result),
   355  		autorest.ByClosing())
   356  	result.Response = autorest.Response{Response: resp}
   357  	return
   358  }
   359  
   360  // CreateImagesFromUrls this API accepts a batch of urls, and optionally tags, to create images. There is a limit of 64
   361  // images and 20 tags.
   362  // Parameters:
   363  // projectID - the project id.
   364  // batch - image urls and tag ids. Limited to 64 images and 20 tags per batch.
   365  func (client BaseClient) CreateImagesFromUrls(ctx context.Context, projectID uuid.UUID, batch ImageURLCreateBatch) (result ImageCreateSummary, err error) {
   366  	if tracing.IsEnabled() {
   367  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromUrls")
   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.CreateImagesFromUrlsPreparer(ctx, projectID, batch)
   377  	if err != nil {
   378  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromUrls", nil, "Failure preparing request")
   379  		return
   380  	}
   381  
   382  	resp, err := client.CreateImagesFromUrlsSender(req)
   383  	if err != nil {
   384  		result.Response = autorest.Response{Response: resp}
   385  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromUrls", resp, "Failure sending request")
   386  		return
   387  	}
   388  
   389  	result, err = client.CreateImagesFromUrlsResponder(resp)
   390  	if err != nil {
   391  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromUrls", resp, "Failure responding to request")
   392  		return
   393  	}
   394  
   395  	return
   396  }
   397  
   398  // CreateImagesFromUrlsPreparer prepares the CreateImagesFromUrls request.
   399  func (client BaseClient) CreateImagesFromUrlsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageURLCreateBatch) (*http.Request, error) {
   400  	urlParameters := map[string]interface{}{
   401  		"Endpoint": client.Endpoint,
   402  	}
   403  
   404  	pathParameters := map[string]interface{}{
   405  		"projectId": autorest.Encode("path", projectID),
   406  	}
   407  
   408  	preparer := autorest.CreatePreparer(
   409  		autorest.AsContentType("application/json; charset=utf-8"),
   410  		autorest.AsPost(),
   411  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   412  		autorest.WithPathParameters("/projects/{projectId}/images/urls", pathParameters),
   413  		autorest.WithJSON(batch),
   414  		autorest.WithHeader("Training-Key", client.APIKey))
   415  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   416  }
   417  
   418  // CreateImagesFromUrlsSender sends the CreateImagesFromUrls request. The method will close the
   419  // http.Response Body if it receives an error.
   420  func (client BaseClient) CreateImagesFromUrlsSender(req *http.Request) (*http.Response, error) {
   421  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   422  }
   423  
   424  // CreateImagesFromUrlsResponder handles the response to the CreateImagesFromUrls request. The method always
   425  // closes the http.Response Body.
   426  func (client BaseClient) CreateImagesFromUrlsResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   427  	err = autorest.Respond(
   428  		resp,
   429  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   430  		autorest.ByUnmarshallingJSON(&result),
   431  		autorest.ByClosing())
   432  	result.Response = autorest.Response{Response: resp}
   433  	return
   434  }
   435  
   436  // CreateImageTags sends the create image tags request.
   437  // Parameters:
   438  // projectID - the project id.
   439  // batch - batch of image tags. Limited to 128 tags per batch.
   440  func (client BaseClient) CreateImageTags(ctx context.Context, projectID uuid.UUID, batch ImageTagCreateBatch) (result ImageTagCreateSummary, err error) {
   441  	if tracing.IsEnabled() {
   442  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImageTags")
   443  		defer func() {
   444  			sc := -1
   445  			if result.Response.Response != nil {
   446  				sc = result.Response.Response.StatusCode
   447  			}
   448  			tracing.EndSpan(ctx, sc, err)
   449  		}()
   450  	}
   451  	req, err := client.CreateImageTagsPreparer(ctx, projectID, batch)
   452  	if err != nil {
   453  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageTags", nil, "Failure preparing request")
   454  		return
   455  	}
   456  
   457  	resp, err := client.CreateImageTagsSender(req)
   458  	if err != nil {
   459  		result.Response = autorest.Response{Response: resp}
   460  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageTags", resp, "Failure sending request")
   461  		return
   462  	}
   463  
   464  	result, err = client.CreateImageTagsResponder(resp)
   465  	if err != nil {
   466  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageTags", resp, "Failure responding to request")
   467  		return
   468  	}
   469  
   470  	return
   471  }
   472  
   473  // CreateImageTagsPreparer prepares the CreateImageTags request.
   474  func (client BaseClient) CreateImageTagsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageTagCreateBatch) (*http.Request, error) {
   475  	urlParameters := map[string]interface{}{
   476  		"Endpoint": client.Endpoint,
   477  	}
   478  
   479  	pathParameters := map[string]interface{}{
   480  		"projectId": autorest.Encode("path", projectID),
   481  	}
   482  
   483  	preparer := autorest.CreatePreparer(
   484  		autorest.AsContentType("application/json; charset=utf-8"),
   485  		autorest.AsPost(),
   486  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   487  		autorest.WithPathParameters("/projects/{projectId}/images/tags", pathParameters),
   488  		autorest.WithJSON(batch),
   489  		autorest.WithHeader("Training-Key", client.APIKey))
   490  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   491  }
   492  
   493  // CreateImageTagsSender sends the CreateImageTags request. The method will close the
   494  // http.Response Body if it receives an error.
   495  func (client BaseClient) CreateImageTagsSender(req *http.Request) (*http.Response, error) {
   496  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   497  }
   498  
   499  // CreateImageTagsResponder handles the response to the CreateImageTags request. The method always
   500  // closes the http.Response Body.
   501  func (client BaseClient) CreateImageTagsResponder(resp *http.Response) (result ImageTagCreateSummary, err error) {
   502  	err = autorest.Respond(
   503  		resp,
   504  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   505  		autorest.ByUnmarshallingJSON(&result),
   506  		autorest.ByClosing())
   507  	result.Response = autorest.Response{Response: resp}
   508  	return
   509  }
   510  
   511  // CreateProject sends the create project request.
   512  // Parameters:
   513  // name - name of the project.
   514  // description - the description of the project.
   515  // domainID - the id of the domain to use for this project. Defaults to General.
   516  // classificationType - the type of classifier to create for this project.
   517  func (client BaseClient) CreateProject(ctx context.Context, name string, description string, domainID *uuid.UUID, classificationType string) (result Project, err error) {
   518  	if tracing.IsEnabled() {
   519  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateProject")
   520  		defer func() {
   521  			sc := -1
   522  			if result.Response.Response != nil {
   523  				sc = result.Response.Response.StatusCode
   524  			}
   525  			tracing.EndSpan(ctx, sc, err)
   526  		}()
   527  	}
   528  	req, err := client.CreateProjectPreparer(ctx, name, description, domainID, classificationType)
   529  	if err != nil {
   530  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateProject", nil, "Failure preparing request")
   531  		return
   532  	}
   533  
   534  	resp, err := client.CreateProjectSender(req)
   535  	if err != nil {
   536  		result.Response = autorest.Response{Response: resp}
   537  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateProject", resp, "Failure sending request")
   538  		return
   539  	}
   540  
   541  	result, err = client.CreateProjectResponder(resp)
   542  	if err != nil {
   543  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateProject", resp, "Failure responding to request")
   544  		return
   545  	}
   546  
   547  	return
   548  }
   549  
   550  // CreateProjectPreparer prepares the CreateProject request.
   551  func (client BaseClient) CreateProjectPreparer(ctx context.Context, name string, description string, domainID *uuid.UUID, classificationType string) (*http.Request, error) {
   552  	urlParameters := map[string]interface{}{
   553  		"Endpoint": client.Endpoint,
   554  	}
   555  
   556  	queryParameters := map[string]interface{}{
   557  		"name": autorest.Encode("query", name),
   558  	}
   559  	if len(description) > 0 {
   560  		queryParameters["description"] = autorest.Encode("query", description)
   561  	}
   562  	if domainID != nil {
   563  		queryParameters["domainId"] = autorest.Encode("query", *domainID)
   564  	}
   565  	if len(string(classificationType)) > 0 {
   566  		queryParameters["classificationType"] = autorest.Encode("query", classificationType)
   567  	}
   568  
   569  	preparer := autorest.CreatePreparer(
   570  		autorest.AsPost(),
   571  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   572  		autorest.WithPath("/projects"),
   573  		autorest.WithQueryParameters(queryParameters),
   574  		autorest.WithHeader("Training-Key", client.APIKey))
   575  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   576  }
   577  
   578  // CreateProjectSender sends the CreateProject request. The method will close the
   579  // http.Response Body if it receives an error.
   580  func (client BaseClient) CreateProjectSender(req *http.Request) (*http.Response, error) {
   581  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   582  }
   583  
   584  // CreateProjectResponder handles the response to the CreateProject request. The method always
   585  // closes the http.Response Body.
   586  func (client BaseClient) CreateProjectResponder(resp *http.Response) (result Project, err error) {
   587  	err = autorest.Respond(
   588  		resp,
   589  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   590  		autorest.ByUnmarshallingJSON(&result),
   591  		autorest.ByClosing())
   592  	result.Response = autorest.Response{Response: resp}
   593  	return
   594  }
   595  
   596  // CreateTag sends the create tag request.
   597  // Parameters:
   598  // projectID - the project id.
   599  // name - the tag name.
   600  // description - optional description for the tag.
   601  // typeParameter - optional type for the tag.
   602  func (client BaseClient) CreateTag(ctx context.Context, projectID uuid.UUID, name string, description string, typeParameter string) (result Tag, err error) {
   603  	if tracing.IsEnabled() {
   604  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateTag")
   605  		defer func() {
   606  			sc := -1
   607  			if result.Response.Response != nil {
   608  				sc = result.Response.Response.StatusCode
   609  			}
   610  			tracing.EndSpan(ctx, sc, err)
   611  		}()
   612  	}
   613  	req, err := client.CreateTagPreparer(ctx, projectID, name, description, typeParameter)
   614  	if err != nil {
   615  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateTag", nil, "Failure preparing request")
   616  		return
   617  	}
   618  
   619  	resp, err := client.CreateTagSender(req)
   620  	if err != nil {
   621  		result.Response = autorest.Response{Response: resp}
   622  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateTag", resp, "Failure sending request")
   623  		return
   624  	}
   625  
   626  	result, err = client.CreateTagResponder(resp)
   627  	if err != nil {
   628  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateTag", resp, "Failure responding to request")
   629  		return
   630  	}
   631  
   632  	return
   633  }
   634  
   635  // CreateTagPreparer prepares the CreateTag request.
   636  func (client BaseClient) CreateTagPreparer(ctx context.Context, projectID uuid.UUID, name string, description string, typeParameter string) (*http.Request, error) {
   637  	urlParameters := map[string]interface{}{
   638  		"Endpoint": client.Endpoint,
   639  	}
   640  
   641  	pathParameters := map[string]interface{}{
   642  		"projectId": autorest.Encode("path", projectID),
   643  	}
   644  
   645  	queryParameters := map[string]interface{}{
   646  		"name": autorest.Encode("query", name),
   647  	}
   648  	if len(description) > 0 {
   649  		queryParameters["description"] = autorest.Encode("query", description)
   650  	}
   651  	if len(string(typeParameter)) > 0 {
   652  		queryParameters["type"] = autorest.Encode("query", typeParameter)
   653  	}
   654  
   655  	preparer := autorest.CreatePreparer(
   656  		autorest.AsPost(),
   657  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   658  		autorest.WithPathParameters("/projects/{projectId}/tags", pathParameters),
   659  		autorest.WithQueryParameters(queryParameters),
   660  		autorest.WithHeader("Training-Key", client.APIKey))
   661  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   662  }
   663  
   664  // CreateTagSender sends the CreateTag request. The method will close the
   665  // http.Response Body if it receives an error.
   666  func (client BaseClient) CreateTagSender(req *http.Request) (*http.Response, error) {
   667  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   668  }
   669  
   670  // CreateTagResponder handles the response to the CreateTag request. The method always
   671  // closes the http.Response Body.
   672  func (client BaseClient) CreateTagResponder(resp *http.Response) (result Tag, err error) {
   673  	err = autorest.Respond(
   674  		resp,
   675  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   676  		autorest.ByUnmarshallingJSON(&result),
   677  		autorest.ByClosing())
   678  	result.Response = autorest.Response{Response: resp}
   679  	return
   680  }
   681  
   682  // DeleteImageRegions sends the delete image regions request.
   683  // Parameters:
   684  // projectID - the project id.
   685  // regionIds - regions to delete. Limited to 64.
   686  func (client BaseClient) DeleteImageRegions(ctx context.Context, projectID uuid.UUID, regionIds []string) (result autorest.Response, err error) {
   687  	if tracing.IsEnabled() {
   688  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImageRegions")
   689  		defer func() {
   690  			sc := -1
   691  			if result.Response != nil {
   692  				sc = result.Response.StatusCode
   693  			}
   694  			tracing.EndSpan(ctx, sc, err)
   695  		}()
   696  	}
   697  	if err := validation.Validate([]validation.Validation{
   698  		{TargetValue: regionIds,
   699  			Constraints: []validation.Constraint{{Target: "regionIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   700  		return result, validation.NewError("training.BaseClient", "DeleteImageRegions", err.Error())
   701  	}
   702  
   703  	req, err := client.DeleteImageRegionsPreparer(ctx, projectID, regionIds)
   704  	if err != nil {
   705  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageRegions", nil, "Failure preparing request")
   706  		return
   707  	}
   708  
   709  	resp, err := client.DeleteImageRegionsSender(req)
   710  	if err != nil {
   711  		result.Response = resp
   712  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageRegions", resp, "Failure sending request")
   713  		return
   714  	}
   715  
   716  	result, err = client.DeleteImageRegionsResponder(resp)
   717  	if err != nil {
   718  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageRegions", resp, "Failure responding to request")
   719  		return
   720  	}
   721  
   722  	return
   723  }
   724  
   725  // DeleteImageRegionsPreparer prepares the DeleteImageRegions request.
   726  func (client BaseClient) DeleteImageRegionsPreparer(ctx context.Context, projectID uuid.UUID, regionIds []string) (*http.Request, error) {
   727  	urlParameters := map[string]interface{}{
   728  		"Endpoint": client.Endpoint,
   729  	}
   730  
   731  	pathParameters := map[string]interface{}{
   732  		"projectId": autorest.Encode("path", projectID),
   733  	}
   734  
   735  	queryParameters := map[string]interface{}{
   736  		"regionIds": autorest.Encode("query", regionIds, ","),
   737  	}
   738  
   739  	preparer := autorest.CreatePreparer(
   740  		autorest.AsDelete(),
   741  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   742  		autorest.WithPathParameters("/projects/{projectId}/images/regions", pathParameters),
   743  		autorest.WithQueryParameters(queryParameters),
   744  		autorest.WithHeader("Training-Key", client.APIKey))
   745  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   746  }
   747  
   748  // DeleteImageRegionsSender sends the DeleteImageRegions request. The method will close the
   749  // http.Response Body if it receives an error.
   750  func (client BaseClient) DeleteImageRegionsSender(req *http.Request) (*http.Response, error) {
   751  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   752  }
   753  
   754  // DeleteImageRegionsResponder handles the response to the DeleteImageRegions request. The method always
   755  // closes the http.Response Body.
   756  func (client BaseClient) DeleteImageRegionsResponder(resp *http.Response) (result autorest.Response, err error) {
   757  	err = autorest.Respond(
   758  		resp,
   759  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   760  		autorest.ByClosing())
   761  	result.Response = resp
   762  	return
   763  }
   764  
   765  // DeleteImages sends the delete images request.
   766  // Parameters:
   767  // projectID - the project id.
   768  // imageIds - ids of the images to be deleted. Limited to 256 images per batch.
   769  func (client BaseClient) DeleteImages(ctx context.Context, projectID uuid.UUID, imageIds []string) (result autorest.Response, err error) {
   770  	if tracing.IsEnabled() {
   771  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImages")
   772  		defer func() {
   773  			sc := -1
   774  			if result.Response != nil {
   775  				sc = result.Response.StatusCode
   776  			}
   777  			tracing.EndSpan(ctx, sc, err)
   778  		}()
   779  	}
   780  	if err := validation.Validate([]validation.Validation{
   781  		{TargetValue: imageIds,
   782  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   783  		return result, validation.NewError("training.BaseClient", "DeleteImages", err.Error())
   784  	}
   785  
   786  	req, err := client.DeleteImagesPreparer(ctx, projectID, imageIds)
   787  	if err != nil {
   788  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", nil, "Failure preparing request")
   789  		return
   790  	}
   791  
   792  	resp, err := client.DeleteImagesSender(req)
   793  	if err != nil {
   794  		result.Response = resp
   795  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", resp, "Failure sending request")
   796  		return
   797  	}
   798  
   799  	result, err = client.DeleteImagesResponder(resp)
   800  	if err != nil {
   801  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", resp, "Failure responding to request")
   802  		return
   803  	}
   804  
   805  	return
   806  }
   807  
   808  // DeleteImagesPreparer prepares the DeleteImages request.
   809  func (client BaseClient) DeleteImagesPreparer(ctx context.Context, projectID uuid.UUID, imageIds []string) (*http.Request, error) {
   810  	urlParameters := map[string]interface{}{
   811  		"Endpoint": client.Endpoint,
   812  	}
   813  
   814  	pathParameters := map[string]interface{}{
   815  		"projectId": autorest.Encode("path", projectID),
   816  	}
   817  
   818  	queryParameters := map[string]interface{}{
   819  		"imageIds": autorest.Encode("query", imageIds, ","),
   820  	}
   821  
   822  	preparer := autorest.CreatePreparer(
   823  		autorest.AsDelete(),
   824  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   825  		autorest.WithPathParameters("/projects/{projectId}/images", pathParameters),
   826  		autorest.WithQueryParameters(queryParameters),
   827  		autorest.WithHeader("Training-Key", client.APIKey))
   828  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   829  }
   830  
   831  // DeleteImagesSender sends the DeleteImages request. The method will close the
   832  // http.Response Body if it receives an error.
   833  func (client BaseClient) DeleteImagesSender(req *http.Request) (*http.Response, error) {
   834  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   835  }
   836  
   837  // DeleteImagesResponder handles the response to the DeleteImages request. The method always
   838  // closes the http.Response Body.
   839  func (client BaseClient) DeleteImagesResponder(resp *http.Response) (result autorest.Response, err error) {
   840  	err = autorest.Respond(
   841  		resp,
   842  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   843  		autorest.ByClosing())
   844  	result.Response = resp
   845  	return
   846  }
   847  
   848  // DeleteImageTags sends the delete image tags request.
   849  // Parameters:
   850  // projectID - the project id.
   851  // imageIds - image ids. Limited to 64 images.
   852  // tagIds - tags to be deleted from the specified images. Limited to 20 tags.
   853  func (client BaseClient) DeleteImageTags(ctx context.Context, projectID uuid.UUID, imageIds []string, tagIds []string) (result autorest.Response, err error) {
   854  	if tracing.IsEnabled() {
   855  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImageTags")
   856  		defer func() {
   857  			sc := -1
   858  			if result.Response != nil {
   859  				sc = result.Response.StatusCode
   860  			}
   861  			tracing.EndSpan(ctx, sc, err)
   862  		}()
   863  	}
   864  	if err := validation.Validate([]validation.Validation{
   865  		{TargetValue: imageIds,
   866  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: true, Chain: nil}}},
   867  		{TargetValue: tagIds,
   868  			Constraints: []validation.Constraint{{Target: "tagIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   869  		return result, validation.NewError("training.BaseClient", "DeleteImageTags", err.Error())
   870  	}
   871  
   872  	req, err := client.DeleteImageTagsPreparer(ctx, projectID, imageIds, tagIds)
   873  	if err != nil {
   874  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", nil, "Failure preparing request")
   875  		return
   876  	}
   877  
   878  	resp, err := client.DeleteImageTagsSender(req)
   879  	if err != nil {
   880  		result.Response = resp
   881  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", resp, "Failure sending request")
   882  		return
   883  	}
   884  
   885  	result, err = client.DeleteImageTagsResponder(resp)
   886  	if err != nil {
   887  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", resp, "Failure responding to request")
   888  		return
   889  	}
   890  
   891  	return
   892  }
   893  
   894  // DeleteImageTagsPreparer prepares the DeleteImageTags request.
   895  func (client BaseClient) DeleteImageTagsPreparer(ctx context.Context, projectID uuid.UUID, imageIds []string, tagIds []string) (*http.Request, error) {
   896  	urlParameters := map[string]interface{}{
   897  		"Endpoint": client.Endpoint,
   898  	}
   899  
   900  	pathParameters := map[string]interface{}{
   901  		"projectId": autorest.Encode("path", projectID),
   902  	}
   903  
   904  	queryParameters := map[string]interface{}{
   905  		"imageIds": autorest.Encode("query", imageIds, ","),
   906  		"tagIds":   autorest.Encode("query", tagIds, ","),
   907  	}
   908  
   909  	preparer := autorest.CreatePreparer(
   910  		autorest.AsDelete(),
   911  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   912  		autorest.WithPathParameters("/projects/{projectId}/images/tags", pathParameters),
   913  		autorest.WithQueryParameters(queryParameters),
   914  		autorest.WithHeader("Training-Key", client.APIKey))
   915  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   916  }
   917  
   918  // DeleteImageTagsSender sends the DeleteImageTags request. The method will close the
   919  // http.Response Body if it receives an error.
   920  func (client BaseClient) DeleteImageTagsSender(req *http.Request) (*http.Response, error) {
   921  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   922  }
   923  
   924  // DeleteImageTagsResponder handles the response to the DeleteImageTags request. The method always
   925  // closes the http.Response Body.
   926  func (client BaseClient) DeleteImageTagsResponder(resp *http.Response) (result autorest.Response, err error) {
   927  	err = autorest.Respond(
   928  		resp,
   929  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   930  		autorest.ByClosing())
   931  	result.Response = resp
   932  	return
   933  }
   934  
   935  // DeleteIteration sends the delete iteration request.
   936  // Parameters:
   937  // projectID - the project id.
   938  // iterationID - the iteration id.
   939  func (client BaseClient) DeleteIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result autorest.Response, err error) {
   940  	if tracing.IsEnabled() {
   941  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteIteration")
   942  		defer func() {
   943  			sc := -1
   944  			if result.Response != nil {
   945  				sc = result.Response.StatusCode
   946  			}
   947  			tracing.EndSpan(ctx, sc, err)
   948  		}()
   949  	}
   950  	req, err := client.DeleteIterationPreparer(ctx, projectID, iterationID)
   951  	if err != nil {
   952  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", nil, "Failure preparing request")
   953  		return
   954  	}
   955  
   956  	resp, err := client.DeleteIterationSender(req)
   957  	if err != nil {
   958  		result.Response = resp
   959  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", resp, "Failure sending request")
   960  		return
   961  	}
   962  
   963  	result, err = client.DeleteIterationResponder(resp)
   964  	if err != nil {
   965  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", resp, "Failure responding to request")
   966  		return
   967  	}
   968  
   969  	return
   970  }
   971  
   972  // DeleteIterationPreparer prepares the DeleteIteration request.
   973  func (client BaseClient) DeleteIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
   974  	urlParameters := map[string]interface{}{
   975  		"Endpoint": client.Endpoint,
   976  	}
   977  
   978  	pathParameters := map[string]interface{}{
   979  		"iterationId": autorest.Encode("path", iterationID),
   980  		"projectId":   autorest.Encode("path", projectID),
   981  	}
   982  
   983  	preparer := autorest.CreatePreparer(
   984  		autorest.AsDelete(),
   985  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
   986  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
   987  		autorest.WithHeader("Training-Key", client.APIKey))
   988  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   989  }
   990  
   991  // DeleteIterationSender sends the DeleteIteration request. The method will close the
   992  // http.Response Body if it receives an error.
   993  func (client BaseClient) DeleteIterationSender(req *http.Request) (*http.Response, error) {
   994  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   995  }
   996  
   997  // DeleteIterationResponder handles the response to the DeleteIteration request. The method always
   998  // closes the http.Response Body.
   999  func (client BaseClient) DeleteIterationResponder(resp *http.Response) (result autorest.Response, err error) {
  1000  	err = autorest.Respond(
  1001  		resp,
  1002  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1003  		autorest.ByClosing())
  1004  	result.Response = resp
  1005  	return
  1006  }
  1007  
  1008  // DeletePrediction sends the delete prediction request.
  1009  // Parameters:
  1010  // projectID - the project id.
  1011  // ids - the prediction ids. Limited to 64.
  1012  func (client BaseClient) DeletePrediction(ctx context.Context, projectID uuid.UUID, ids []string) (result autorest.Response, err error) {
  1013  	if tracing.IsEnabled() {
  1014  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeletePrediction")
  1015  		defer func() {
  1016  			sc := -1
  1017  			if result.Response != nil {
  1018  				sc = result.Response.StatusCode
  1019  			}
  1020  			tracing.EndSpan(ctx, sc, err)
  1021  		}()
  1022  	}
  1023  	if err := validation.Validate([]validation.Validation{
  1024  		{TargetValue: ids,
  1025  			Constraints: []validation.Constraint{{Target: "ids", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1026  		return result, validation.NewError("training.BaseClient", "DeletePrediction", err.Error())
  1027  	}
  1028  
  1029  	req, err := client.DeletePredictionPreparer(ctx, projectID, ids)
  1030  	if err != nil {
  1031  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", nil, "Failure preparing request")
  1032  		return
  1033  	}
  1034  
  1035  	resp, err := client.DeletePredictionSender(req)
  1036  	if err != nil {
  1037  		result.Response = resp
  1038  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", resp, "Failure sending request")
  1039  		return
  1040  	}
  1041  
  1042  	result, err = client.DeletePredictionResponder(resp)
  1043  	if err != nil {
  1044  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", resp, "Failure responding to request")
  1045  		return
  1046  	}
  1047  
  1048  	return
  1049  }
  1050  
  1051  // DeletePredictionPreparer prepares the DeletePrediction request.
  1052  func (client BaseClient) DeletePredictionPreparer(ctx context.Context, projectID uuid.UUID, ids []string) (*http.Request, error) {
  1053  	urlParameters := map[string]interface{}{
  1054  		"Endpoint": client.Endpoint,
  1055  	}
  1056  
  1057  	pathParameters := map[string]interface{}{
  1058  		"projectId": autorest.Encode("path", projectID),
  1059  	}
  1060  
  1061  	queryParameters := map[string]interface{}{
  1062  		"ids": autorest.Encode("query", ids, ","),
  1063  	}
  1064  
  1065  	preparer := autorest.CreatePreparer(
  1066  		autorest.AsDelete(),
  1067  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1068  		autorest.WithPathParameters("/projects/{projectId}/predictions", pathParameters),
  1069  		autorest.WithQueryParameters(queryParameters),
  1070  		autorest.WithHeader("Training-Key", client.APIKey))
  1071  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1072  }
  1073  
  1074  // DeletePredictionSender sends the DeletePrediction request. The method will close the
  1075  // http.Response Body if it receives an error.
  1076  func (client BaseClient) DeletePredictionSender(req *http.Request) (*http.Response, error) {
  1077  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1078  }
  1079  
  1080  // DeletePredictionResponder handles the response to the DeletePrediction request. The method always
  1081  // closes the http.Response Body.
  1082  func (client BaseClient) DeletePredictionResponder(resp *http.Response) (result autorest.Response, err error) {
  1083  	err = autorest.Respond(
  1084  		resp,
  1085  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1086  		autorest.ByClosing())
  1087  	result.Response = resp
  1088  	return
  1089  }
  1090  
  1091  // DeleteProject sends the delete project request.
  1092  // Parameters:
  1093  // projectID - the project id.
  1094  func (client BaseClient) DeleteProject(ctx context.Context, projectID uuid.UUID) (result autorest.Response, err error) {
  1095  	if tracing.IsEnabled() {
  1096  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteProject")
  1097  		defer func() {
  1098  			sc := -1
  1099  			if result.Response != nil {
  1100  				sc = result.Response.StatusCode
  1101  			}
  1102  			tracing.EndSpan(ctx, sc, err)
  1103  		}()
  1104  	}
  1105  	req, err := client.DeleteProjectPreparer(ctx, projectID)
  1106  	if err != nil {
  1107  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", nil, "Failure preparing request")
  1108  		return
  1109  	}
  1110  
  1111  	resp, err := client.DeleteProjectSender(req)
  1112  	if err != nil {
  1113  		result.Response = resp
  1114  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", resp, "Failure sending request")
  1115  		return
  1116  	}
  1117  
  1118  	result, err = client.DeleteProjectResponder(resp)
  1119  	if err != nil {
  1120  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", resp, "Failure responding to request")
  1121  		return
  1122  	}
  1123  
  1124  	return
  1125  }
  1126  
  1127  // DeleteProjectPreparer prepares the DeleteProject request.
  1128  func (client BaseClient) DeleteProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  1129  	urlParameters := map[string]interface{}{
  1130  		"Endpoint": client.Endpoint,
  1131  	}
  1132  
  1133  	pathParameters := map[string]interface{}{
  1134  		"projectId": autorest.Encode("path", projectID),
  1135  	}
  1136  
  1137  	preparer := autorest.CreatePreparer(
  1138  		autorest.AsDelete(),
  1139  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1140  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  1141  		autorest.WithHeader("Training-Key", client.APIKey))
  1142  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1143  }
  1144  
  1145  // DeleteProjectSender sends the DeleteProject request. The method will close the
  1146  // http.Response Body if it receives an error.
  1147  func (client BaseClient) DeleteProjectSender(req *http.Request) (*http.Response, error) {
  1148  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1149  }
  1150  
  1151  // DeleteProjectResponder handles the response to the DeleteProject request. The method always
  1152  // closes the http.Response Body.
  1153  func (client BaseClient) DeleteProjectResponder(resp *http.Response) (result autorest.Response, err error) {
  1154  	err = autorest.Respond(
  1155  		resp,
  1156  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1157  		autorest.ByClosing())
  1158  	result.Response = resp
  1159  	return
  1160  }
  1161  
  1162  // DeleteTag sends the delete tag request.
  1163  // Parameters:
  1164  // projectID - the project id.
  1165  // tagID - id of the tag to be deleted.
  1166  func (client BaseClient) DeleteTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID) (result autorest.Response, err error) {
  1167  	if tracing.IsEnabled() {
  1168  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteTag")
  1169  		defer func() {
  1170  			sc := -1
  1171  			if result.Response != nil {
  1172  				sc = result.Response.StatusCode
  1173  			}
  1174  			tracing.EndSpan(ctx, sc, err)
  1175  		}()
  1176  	}
  1177  	req, err := client.DeleteTagPreparer(ctx, projectID, tagID)
  1178  	if err != nil {
  1179  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", nil, "Failure preparing request")
  1180  		return
  1181  	}
  1182  
  1183  	resp, err := client.DeleteTagSender(req)
  1184  	if err != nil {
  1185  		result.Response = resp
  1186  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", resp, "Failure sending request")
  1187  		return
  1188  	}
  1189  
  1190  	result, err = client.DeleteTagResponder(resp)
  1191  	if err != nil {
  1192  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", resp, "Failure responding to request")
  1193  		return
  1194  	}
  1195  
  1196  	return
  1197  }
  1198  
  1199  // DeleteTagPreparer prepares the DeleteTag request.
  1200  func (client BaseClient) DeleteTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID) (*http.Request, error) {
  1201  	urlParameters := map[string]interface{}{
  1202  		"Endpoint": client.Endpoint,
  1203  	}
  1204  
  1205  	pathParameters := map[string]interface{}{
  1206  		"projectId": autorest.Encode("path", projectID),
  1207  		"tagId":     autorest.Encode("path", tagID),
  1208  	}
  1209  
  1210  	preparer := autorest.CreatePreparer(
  1211  		autorest.AsDelete(),
  1212  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1213  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  1214  		autorest.WithHeader("Training-Key", client.APIKey))
  1215  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1216  }
  1217  
  1218  // DeleteTagSender sends the DeleteTag request. The method will close the
  1219  // http.Response Body if it receives an error.
  1220  func (client BaseClient) DeleteTagSender(req *http.Request) (*http.Response, error) {
  1221  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1222  }
  1223  
  1224  // DeleteTagResponder handles the response to the DeleteTag request. The method always
  1225  // closes the http.Response Body.
  1226  func (client BaseClient) DeleteTagResponder(resp *http.Response) (result autorest.Response, err error) {
  1227  	err = autorest.Respond(
  1228  		resp,
  1229  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1230  		autorest.ByClosing())
  1231  	result.Response = resp
  1232  	return
  1233  }
  1234  
  1235  // ExportIteration sends the export iteration request.
  1236  // Parameters:
  1237  // projectID - the project id.
  1238  // iterationID - the iteration id.
  1239  // platform - the target platform.
  1240  // flavor - the flavor of the target platform.
  1241  func (client BaseClient) ExportIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, platform string, flavor string) (result Export, err error) {
  1242  	if tracing.IsEnabled() {
  1243  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.ExportIteration")
  1244  		defer func() {
  1245  			sc := -1
  1246  			if result.Response.Response != nil {
  1247  				sc = result.Response.Response.StatusCode
  1248  			}
  1249  			tracing.EndSpan(ctx, sc, err)
  1250  		}()
  1251  	}
  1252  	req, err := client.ExportIterationPreparer(ctx, projectID, iterationID, platform, flavor)
  1253  	if err != nil {
  1254  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", nil, "Failure preparing request")
  1255  		return
  1256  	}
  1257  
  1258  	resp, err := client.ExportIterationSender(req)
  1259  	if err != nil {
  1260  		result.Response = autorest.Response{Response: resp}
  1261  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", resp, "Failure sending request")
  1262  		return
  1263  	}
  1264  
  1265  	result, err = client.ExportIterationResponder(resp)
  1266  	if err != nil {
  1267  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", resp, "Failure responding to request")
  1268  		return
  1269  	}
  1270  
  1271  	return
  1272  }
  1273  
  1274  // ExportIterationPreparer prepares the ExportIteration request.
  1275  func (client BaseClient) ExportIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, platform string, flavor string) (*http.Request, error) {
  1276  	urlParameters := map[string]interface{}{
  1277  		"Endpoint": client.Endpoint,
  1278  	}
  1279  
  1280  	pathParameters := map[string]interface{}{
  1281  		"iterationId": autorest.Encode("path", iterationID),
  1282  		"projectId":   autorest.Encode("path", projectID),
  1283  	}
  1284  
  1285  	queryParameters := map[string]interface{}{
  1286  		"platform": autorest.Encode("query", platform),
  1287  	}
  1288  	if len(string(flavor)) > 0 {
  1289  		queryParameters["flavor"] = autorest.Encode("query", flavor)
  1290  	}
  1291  
  1292  	preparer := autorest.CreatePreparer(
  1293  		autorest.AsPost(),
  1294  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1295  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/export", pathParameters),
  1296  		autorest.WithQueryParameters(queryParameters),
  1297  		autorest.WithHeader("Training-Key", client.APIKey))
  1298  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1299  }
  1300  
  1301  // ExportIterationSender sends the ExportIteration request. The method will close the
  1302  // http.Response Body if it receives an error.
  1303  func (client BaseClient) ExportIterationSender(req *http.Request) (*http.Response, error) {
  1304  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1305  }
  1306  
  1307  // ExportIterationResponder handles the response to the ExportIteration request. The method always
  1308  // closes the http.Response Body.
  1309  func (client BaseClient) ExportIterationResponder(resp *http.Response) (result Export, err error) {
  1310  	err = autorest.Respond(
  1311  		resp,
  1312  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1313  		autorest.ByUnmarshallingJSON(&result),
  1314  		autorest.ByClosing())
  1315  	result.Response = autorest.Response{Response: resp}
  1316  	return
  1317  }
  1318  
  1319  // GetDomain sends the get domain request.
  1320  // Parameters:
  1321  // domainID - the id of the domain to get information about.
  1322  func (client BaseClient) GetDomain(ctx context.Context, domainID uuid.UUID) (result Domain, err error) {
  1323  	if tracing.IsEnabled() {
  1324  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetDomain")
  1325  		defer func() {
  1326  			sc := -1
  1327  			if result.Response.Response != nil {
  1328  				sc = result.Response.Response.StatusCode
  1329  			}
  1330  			tracing.EndSpan(ctx, sc, err)
  1331  		}()
  1332  	}
  1333  	req, err := client.GetDomainPreparer(ctx, domainID)
  1334  	if err != nil {
  1335  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", nil, "Failure preparing request")
  1336  		return
  1337  	}
  1338  
  1339  	resp, err := client.GetDomainSender(req)
  1340  	if err != nil {
  1341  		result.Response = autorest.Response{Response: resp}
  1342  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", resp, "Failure sending request")
  1343  		return
  1344  	}
  1345  
  1346  	result, err = client.GetDomainResponder(resp)
  1347  	if err != nil {
  1348  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", resp, "Failure responding to request")
  1349  		return
  1350  	}
  1351  
  1352  	return
  1353  }
  1354  
  1355  // GetDomainPreparer prepares the GetDomain request.
  1356  func (client BaseClient) GetDomainPreparer(ctx context.Context, domainID uuid.UUID) (*http.Request, error) {
  1357  	urlParameters := map[string]interface{}{
  1358  		"Endpoint": client.Endpoint,
  1359  	}
  1360  
  1361  	pathParameters := map[string]interface{}{
  1362  		"domainId": autorest.Encode("path", domainID),
  1363  	}
  1364  
  1365  	preparer := autorest.CreatePreparer(
  1366  		autorest.AsGet(),
  1367  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1368  		autorest.WithPathParameters("/domains/{domainId}", pathParameters),
  1369  		autorest.WithHeader("Training-Key", client.APIKey))
  1370  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1371  }
  1372  
  1373  // GetDomainSender sends the GetDomain request. The method will close the
  1374  // http.Response Body if it receives an error.
  1375  func (client BaseClient) GetDomainSender(req *http.Request) (*http.Response, error) {
  1376  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1377  }
  1378  
  1379  // GetDomainResponder handles the response to the GetDomain request. The method always
  1380  // closes the http.Response Body.
  1381  func (client BaseClient) GetDomainResponder(resp *http.Response) (result Domain, err error) {
  1382  	err = autorest.Respond(
  1383  		resp,
  1384  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1385  		autorest.ByUnmarshallingJSON(&result),
  1386  		autorest.ByClosing())
  1387  	result.Response = autorest.Response{Response: resp}
  1388  	return
  1389  }
  1390  
  1391  // GetDomains sends the get domains request.
  1392  func (client BaseClient) GetDomains(ctx context.Context) (result ListDomain, err error) {
  1393  	if tracing.IsEnabled() {
  1394  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetDomains")
  1395  		defer func() {
  1396  			sc := -1
  1397  			if result.Response.Response != nil {
  1398  				sc = result.Response.Response.StatusCode
  1399  			}
  1400  			tracing.EndSpan(ctx, sc, err)
  1401  		}()
  1402  	}
  1403  	req, err := client.GetDomainsPreparer(ctx)
  1404  	if err != nil {
  1405  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", nil, "Failure preparing request")
  1406  		return
  1407  	}
  1408  
  1409  	resp, err := client.GetDomainsSender(req)
  1410  	if err != nil {
  1411  		result.Response = autorest.Response{Response: resp}
  1412  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", resp, "Failure sending request")
  1413  		return
  1414  	}
  1415  
  1416  	result, err = client.GetDomainsResponder(resp)
  1417  	if err != nil {
  1418  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", resp, "Failure responding to request")
  1419  		return
  1420  	}
  1421  
  1422  	return
  1423  }
  1424  
  1425  // GetDomainsPreparer prepares the GetDomains request.
  1426  func (client BaseClient) GetDomainsPreparer(ctx context.Context) (*http.Request, error) {
  1427  	urlParameters := map[string]interface{}{
  1428  		"Endpoint": client.Endpoint,
  1429  	}
  1430  
  1431  	preparer := autorest.CreatePreparer(
  1432  		autorest.AsGet(),
  1433  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1434  		autorest.WithPath("/domains"),
  1435  		autorest.WithHeader("Training-Key", client.APIKey))
  1436  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1437  }
  1438  
  1439  // GetDomainsSender sends the GetDomains request. The method will close the
  1440  // http.Response Body if it receives an error.
  1441  func (client BaseClient) GetDomainsSender(req *http.Request) (*http.Response, error) {
  1442  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1443  }
  1444  
  1445  // GetDomainsResponder handles the response to the GetDomains request. The method always
  1446  // closes the http.Response Body.
  1447  func (client BaseClient) GetDomainsResponder(resp *http.Response) (result ListDomain, err error) {
  1448  	err = autorest.Respond(
  1449  		resp,
  1450  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1451  		autorest.ByUnmarshallingJSON(&result.Value),
  1452  		autorest.ByClosing())
  1453  	result.Response = autorest.Response{Response: resp}
  1454  	return
  1455  }
  1456  
  1457  // GetExports sends the get exports request.
  1458  // Parameters:
  1459  // projectID - the project id.
  1460  // iterationID - the iteration id.
  1461  func (client BaseClient) GetExports(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result ListExport, err error) {
  1462  	if tracing.IsEnabled() {
  1463  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetExports")
  1464  		defer func() {
  1465  			sc := -1
  1466  			if result.Response.Response != nil {
  1467  				sc = result.Response.Response.StatusCode
  1468  			}
  1469  			tracing.EndSpan(ctx, sc, err)
  1470  		}()
  1471  	}
  1472  	req, err := client.GetExportsPreparer(ctx, projectID, iterationID)
  1473  	if err != nil {
  1474  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", nil, "Failure preparing request")
  1475  		return
  1476  	}
  1477  
  1478  	resp, err := client.GetExportsSender(req)
  1479  	if err != nil {
  1480  		result.Response = autorest.Response{Response: resp}
  1481  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", resp, "Failure sending request")
  1482  		return
  1483  	}
  1484  
  1485  	result, err = client.GetExportsResponder(resp)
  1486  	if err != nil {
  1487  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", resp, "Failure responding to request")
  1488  		return
  1489  	}
  1490  
  1491  	return
  1492  }
  1493  
  1494  // GetExportsPreparer prepares the GetExports request.
  1495  func (client BaseClient) GetExportsPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  1496  	urlParameters := map[string]interface{}{
  1497  		"Endpoint": client.Endpoint,
  1498  	}
  1499  
  1500  	pathParameters := map[string]interface{}{
  1501  		"iterationId": autorest.Encode("path", iterationID),
  1502  		"projectId":   autorest.Encode("path", projectID),
  1503  	}
  1504  
  1505  	preparer := autorest.CreatePreparer(
  1506  		autorest.AsGet(),
  1507  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1508  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/export", pathParameters),
  1509  		autorest.WithHeader("Training-Key", client.APIKey))
  1510  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1511  }
  1512  
  1513  // GetExportsSender sends the GetExports request. The method will close the
  1514  // http.Response Body if it receives an error.
  1515  func (client BaseClient) GetExportsSender(req *http.Request) (*http.Response, error) {
  1516  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1517  }
  1518  
  1519  // GetExportsResponder handles the response to the GetExports request. The method always
  1520  // closes the http.Response Body.
  1521  func (client BaseClient) GetExportsResponder(resp *http.Response) (result ListExport, err error) {
  1522  	err = autorest.Respond(
  1523  		resp,
  1524  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1525  		autorest.ByUnmarshallingJSON(&result.Value),
  1526  		autorest.ByClosing())
  1527  	result.Response = autorest.Response{Response: resp}
  1528  	return
  1529  }
  1530  
  1531  // GetImagePerformanceCount the filtering is on an and/or relationship. For example, if the provided tag ids are for
  1532  // the "Dog" and
  1533  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  1534  // Parameters:
  1535  // projectID - the project id.
  1536  // iterationID - the iteration id. Defaults to workspace.
  1537  // tagIds - a list of tags ids to filter the images to count. Defaults to all tags when null.
  1538  func (client BaseClient) GetImagePerformanceCount(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string) (result Int32, err error) {
  1539  	if tracing.IsEnabled() {
  1540  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagePerformanceCount")
  1541  		defer func() {
  1542  			sc := -1
  1543  			if result.Response.Response != nil {
  1544  				sc = result.Response.Response.StatusCode
  1545  			}
  1546  			tracing.EndSpan(ctx, sc, err)
  1547  		}()
  1548  	}
  1549  	req, err := client.GetImagePerformanceCountPreparer(ctx, projectID, iterationID, tagIds)
  1550  	if err != nil {
  1551  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", nil, "Failure preparing request")
  1552  		return
  1553  	}
  1554  
  1555  	resp, err := client.GetImagePerformanceCountSender(req)
  1556  	if err != nil {
  1557  		result.Response = autorest.Response{Response: resp}
  1558  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", resp, "Failure sending request")
  1559  		return
  1560  	}
  1561  
  1562  	result, err = client.GetImagePerformanceCountResponder(resp)
  1563  	if err != nil {
  1564  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", resp, "Failure responding to request")
  1565  		return
  1566  	}
  1567  
  1568  	return
  1569  }
  1570  
  1571  // GetImagePerformanceCountPreparer prepares the GetImagePerformanceCount request.
  1572  func (client BaseClient) GetImagePerformanceCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string) (*http.Request, error) {
  1573  	urlParameters := map[string]interface{}{
  1574  		"Endpoint": client.Endpoint,
  1575  	}
  1576  
  1577  	pathParameters := map[string]interface{}{
  1578  		"iterationId": autorest.Encode("path", iterationID),
  1579  		"projectId":   autorest.Encode("path", projectID),
  1580  	}
  1581  
  1582  	queryParameters := map[string]interface{}{}
  1583  	if tagIds != nil && len(tagIds) > 0 {
  1584  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  1585  	}
  1586  
  1587  	preparer := autorest.CreatePreparer(
  1588  		autorest.AsGet(),
  1589  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1590  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance/images/count", pathParameters),
  1591  		autorest.WithQueryParameters(queryParameters),
  1592  		autorest.WithHeader("Training-Key", client.APIKey))
  1593  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1594  }
  1595  
  1596  // GetImagePerformanceCountSender sends the GetImagePerformanceCount request. The method will close the
  1597  // http.Response Body if it receives an error.
  1598  func (client BaseClient) GetImagePerformanceCountSender(req *http.Request) (*http.Response, error) {
  1599  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1600  }
  1601  
  1602  // GetImagePerformanceCountResponder handles the response to the GetImagePerformanceCount request. The method always
  1603  // closes the http.Response Body.
  1604  func (client BaseClient) GetImagePerformanceCountResponder(resp *http.Response) (result Int32, err error) {
  1605  	err = autorest.Respond(
  1606  		resp,
  1607  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1608  		autorest.ByUnmarshallingJSON(&result.Value),
  1609  		autorest.ByClosing())
  1610  	result.Response = autorest.Response{Response: resp}
  1611  	return
  1612  }
  1613  
  1614  // GetImagePerformances this API supports batching and range selection. By default it will only return first 50 images
  1615  // matching images.
  1616  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  1617  // The filtering is on an and/or relationship. For example, if the provided tag ids are for the "Dog" and
  1618  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  1619  // Parameters:
  1620  // projectID - the project id.
  1621  // iterationID - the iteration id. Defaults to workspace.
  1622  // tagIds - a list of tags ids to filter the images. Defaults to all tagged images when null. Limited to 20.
  1623  // orderBy - the ordering. Defaults to newest.
  1624  // take - maximum number of images to return. Defaults to 50, limited to 256.
  1625  // skip - number of images to skip before beginning the image batch. Defaults to 0.
  1626  func (client BaseClient) GetImagePerformances(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (result ListImagePerformance, err error) {
  1627  	if tracing.IsEnabled() {
  1628  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagePerformances")
  1629  		defer func() {
  1630  			sc := -1
  1631  			if result.Response.Response != nil {
  1632  				sc = result.Response.Response.StatusCode
  1633  			}
  1634  			tracing.EndSpan(ctx, sc, err)
  1635  		}()
  1636  	}
  1637  	req, err := client.GetImagePerformancesPreparer(ctx, projectID, iterationID, tagIds, orderBy, take, skip)
  1638  	if err != nil {
  1639  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", nil, "Failure preparing request")
  1640  		return
  1641  	}
  1642  
  1643  	resp, err := client.GetImagePerformancesSender(req)
  1644  	if err != nil {
  1645  		result.Response = autorest.Response{Response: resp}
  1646  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", resp, "Failure sending request")
  1647  		return
  1648  	}
  1649  
  1650  	result, err = client.GetImagePerformancesResponder(resp)
  1651  	if err != nil {
  1652  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", resp, "Failure responding to request")
  1653  		return
  1654  	}
  1655  
  1656  	return
  1657  }
  1658  
  1659  // GetImagePerformancesPreparer prepares the GetImagePerformances request.
  1660  func (client BaseClient) GetImagePerformancesPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (*http.Request, error) {
  1661  	urlParameters := map[string]interface{}{
  1662  		"Endpoint": client.Endpoint,
  1663  	}
  1664  
  1665  	pathParameters := map[string]interface{}{
  1666  		"iterationId": autorest.Encode("path", iterationID),
  1667  		"projectId":   autorest.Encode("path", projectID),
  1668  	}
  1669  
  1670  	queryParameters := map[string]interface{}{}
  1671  	if tagIds != nil && len(tagIds) > 0 {
  1672  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  1673  	}
  1674  	if len(string(orderBy)) > 0 {
  1675  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  1676  	}
  1677  	if take != nil {
  1678  		queryParameters["take"] = autorest.Encode("query", *take)
  1679  	} else {
  1680  		queryParameters["take"] = autorest.Encode("query", 50)
  1681  	}
  1682  	if skip != nil {
  1683  		queryParameters["skip"] = autorest.Encode("query", *skip)
  1684  	} else {
  1685  		queryParameters["skip"] = autorest.Encode("query", 0)
  1686  	}
  1687  
  1688  	preparer := autorest.CreatePreparer(
  1689  		autorest.AsGet(),
  1690  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1691  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance/images", pathParameters),
  1692  		autorest.WithQueryParameters(queryParameters),
  1693  		autorest.WithHeader("Training-Key", client.APIKey))
  1694  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1695  }
  1696  
  1697  // GetImagePerformancesSender sends the GetImagePerformances request. The method will close the
  1698  // http.Response Body if it receives an error.
  1699  func (client BaseClient) GetImagePerformancesSender(req *http.Request) (*http.Response, error) {
  1700  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1701  }
  1702  
  1703  // GetImagePerformancesResponder handles the response to the GetImagePerformances request. The method always
  1704  // closes the http.Response Body.
  1705  func (client BaseClient) GetImagePerformancesResponder(resp *http.Response) (result ListImagePerformance, err error) {
  1706  	err = autorest.Respond(
  1707  		resp,
  1708  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1709  		autorest.ByUnmarshallingJSON(&result.Value),
  1710  		autorest.ByClosing())
  1711  	result.Response = autorest.Response{Response: resp}
  1712  	return
  1713  }
  1714  
  1715  // GetImageRegionProposals this API will get region proposals for an image along with confidences for the region. It
  1716  // returns an empty array if no proposals are found.
  1717  // Parameters:
  1718  // projectID - the project id.
  1719  // imageID - the image id.
  1720  func (client BaseClient) GetImageRegionProposals(ctx context.Context, projectID uuid.UUID, imageID uuid.UUID) (result ImageRegionProposal, err error) {
  1721  	if tracing.IsEnabled() {
  1722  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImageRegionProposals")
  1723  		defer func() {
  1724  			sc := -1
  1725  			if result.Response.Response != nil {
  1726  				sc = result.Response.Response.StatusCode
  1727  			}
  1728  			tracing.EndSpan(ctx, sc, err)
  1729  		}()
  1730  	}
  1731  	req, err := client.GetImageRegionProposalsPreparer(ctx, projectID, imageID)
  1732  	if err != nil {
  1733  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", nil, "Failure preparing request")
  1734  		return
  1735  	}
  1736  
  1737  	resp, err := client.GetImageRegionProposalsSender(req)
  1738  	if err != nil {
  1739  		result.Response = autorest.Response{Response: resp}
  1740  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", resp, "Failure sending request")
  1741  		return
  1742  	}
  1743  
  1744  	result, err = client.GetImageRegionProposalsResponder(resp)
  1745  	if err != nil {
  1746  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", resp, "Failure responding to request")
  1747  		return
  1748  	}
  1749  
  1750  	return
  1751  }
  1752  
  1753  // GetImageRegionProposalsPreparer prepares the GetImageRegionProposals request.
  1754  func (client BaseClient) GetImageRegionProposalsPreparer(ctx context.Context, projectID uuid.UUID, imageID uuid.UUID) (*http.Request, error) {
  1755  	urlParameters := map[string]interface{}{
  1756  		"Endpoint": client.Endpoint,
  1757  	}
  1758  
  1759  	pathParameters := map[string]interface{}{
  1760  		"imageId":   autorest.Encode("path", imageID),
  1761  		"projectId": autorest.Encode("path", projectID),
  1762  	}
  1763  
  1764  	preparer := autorest.CreatePreparer(
  1765  		autorest.AsPost(),
  1766  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1767  		autorest.WithPathParameters("/{projectId}/images/{imageId}/regionproposals", pathParameters),
  1768  		autorest.WithHeader("Training-Key", client.APIKey))
  1769  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1770  }
  1771  
  1772  // GetImageRegionProposalsSender sends the GetImageRegionProposals request. The method will close the
  1773  // http.Response Body if it receives an error.
  1774  func (client BaseClient) GetImageRegionProposalsSender(req *http.Request) (*http.Response, error) {
  1775  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1776  }
  1777  
  1778  // GetImageRegionProposalsResponder handles the response to the GetImageRegionProposals request. The method always
  1779  // closes the http.Response Body.
  1780  func (client BaseClient) GetImageRegionProposalsResponder(resp *http.Response) (result ImageRegionProposal, err error) {
  1781  	err = autorest.Respond(
  1782  		resp,
  1783  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1784  		autorest.ByUnmarshallingJSON(&result),
  1785  		autorest.ByClosing())
  1786  	result.Response = autorest.Response{Response: resp}
  1787  	return
  1788  }
  1789  
  1790  // GetImagesByIds this API will return a set of Images for the specified tags and optionally iteration. If no iteration
  1791  // is specified the
  1792  // current workspace is used.
  1793  // Parameters:
  1794  // projectID - the project id.
  1795  // imageIds - the list of image ids to retrieve. Limited to 256.
  1796  // iterationID - the iteration id. Defaults to workspace.
  1797  func (client BaseClient) GetImagesByIds(ctx context.Context, projectID uuid.UUID, imageIds []string, iterationID *uuid.UUID) (result ListImage, err error) {
  1798  	if tracing.IsEnabled() {
  1799  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagesByIds")
  1800  		defer func() {
  1801  			sc := -1
  1802  			if result.Response.Response != nil {
  1803  				sc = result.Response.Response.StatusCode
  1804  			}
  1805  			tracing.EndSpan(ctx, sc, err)
  1806  		}()
  1807  	}
  1808  	req, err := client.GetImagesByIdsPreparer(ctx, projectID, imageIds, iterationID)
  1809  	if err != nil {
  1810  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", nil, "Failure preparing request")
  1811  		return
  1812  	}
  1813  
  1814  	resp, err := client.GetImagesByIdsSender(req)
  1815  	if err != nil {
  1816  		result.Response = autorest.Response{Response: resp}
  1817  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", resp, "Failure sending request")
  1818  		return
  1819  	}
  1820  
  1821  	result, err = client.GetImagesByIdsResponder(resp)
  1822  	if err != nil {
  1823  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", resp, "Failure responding to request")
  1824  		return
  1825  	}
  1826  
  1827  	return
  1828  }
  1829  
  1830  // GetImagesByIdsPreparer prepares the GetImagesByIds request.
  1831  func (client BaseClient) GetImagesByIdsPreparer(ctx context.Context, projectID uuid.UUID, imageIds []string, iterationID *uuid.UUID) (*http.Request, error) {
  1832  	urlParameters := map[string]interface{}{
  1833  		"Endpoint": client.Endpoint,
  1834  	}
  1835  
  1836  	pathParameters := map[string]interface{}{
  1837  		"projectId": autorest.Encode("path", projectID),
  1838  	}
  1839  
  1840  	queryParameters := map[string]interface{}{}
  1841  	if imageIds != nil && len(imageIds) > 0 {
  1842  		queryParameters["imageIds"] = autorest.Encode("query", imageIds, ",")
  1843  	}
  1844  	if iterationID != nil {
  1845  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  1846  	}
  1847  
  1848  	preparer := autorest.CreatePreparer(
  1849  		autorest.AsGet(),
  1850  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1851  		autorest.WithPathParameters("/projects/{projectId}/images/id", pathParameters),
  1852  		autorest.WithQueryParameters(queryParameters),
  1853  		autorest.WithHeader("Training-Key", client.APIKey))
  1854  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1855  }
  1856  
  1857  // GetImagesByIdsSender sends the GetImagesByIds request. The method will close the
  1858  // http.Response Body if it receives an error.
  1859  func (client BaseClient) GetImagesByIdsSender(req *http.Request) (*http.Response, error) {
  1860  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1861  }
  1862  
  1863  // GetImagesByIdsResponder handles the response to the GetImagesByIds request. The method always
  1864  // closes the http.Response Body.
  1865  func (client BaseClient) GetImagesByIdsResponder(resp *http.Response) (result ListImage, err error) {
  1866  	err = autorest.Respond(
  1867  		resp,
  1868  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1869  		autorest.ByUnmarshallingJSON(&result.Value),
  1870  		autorest.ByClosing())
  1871  	result.Response = autorest.Response{Response: resp}
  1872  	return
  1873  }
  1874  
  1875  // GetIteration sends the get iteration request.
  1876  // Parameters:
  1877  // projectID - the id of the project the iteration belongs to.
  1878  // iterationID - the id of the iteration to get.
  1879  func (client BaseClient) GetIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result Iteration, err error) {
  1880  	if tracing.IsEnabled() {
  1881  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIteration")
  1882  		defer func() {
  1883  			sc := -1
  1884  			if result.Response.Response != nil {
  1885  				sc = result.Response.Response.StatusCode
  1886  			}
  1887  			tracing.EndSpan(ctx, sc, err)
  1888  		}()
  1889  	}
  1890  	req, err := client.GetIterationPreparer(ctx, projectID, iterationID)
  1891  	if err != nil {
  1892  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", nil, "Failure preparing request")
  1893  		return
  1894  	}
  1895  
  1896  	resp, err := client.GetIterationSender(req)
  1897  	if err != nil {
  1898  		result.Response = autorest.Response{Response: resp}
  1899  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", resp, "Failure sending request")
  1900  		return
  1901  	}
  1902  
  1903  	result, err = client.GetIterationResponder(resp)
  1904  	if err != nil {
  1905  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", resp, "Failure responding to request")
  1906  		return
  1907  	}
  1908  
  1909  	return
  1910  }
  1911  
  1912  // GetIterationPreparer prepares the GetIteration request.
  1913  func (client BaseClient) GetIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  1914  	urlParameters := map[string]interface{}{
  1915  		"Endpoint": client.Endpoint,
  1916  	}
  1917  
  1918  	pathParameters := map[string]interface{}{
  1919  		"iterationId": autorest.Encode("path", iterationID),
  1920  		"projectId":   autorest.Encode("path", projectID),
  1921  	}
  1922  
  1923  	preparer := autorest.CreatePreparer(
  1924  		autorest.AsGet(),
  1925  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  1926  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
  1927  		autorest.WithHeader("Training-Key", client.APIKey))
  1928  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1929  }
  1930  
  1931  // GetIterationSender sends the GetIteration request. The method will close the
  1932  // http.Response Body if it receives an error.
  1933  func (client BaseClient) GetIterationSender(req *http.Request) (*http.Response, error) {
  1934  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1935  }
  1936  
  1937  // GetIterationResponder handles the response to the GetIteration request. The method always
  1938  // closes the http.Response Body.
  1939  func (client BaseClient) GetIterationResponder(resp *http.Response) (result Iteration, err error) {
  1940  	err = autorest.Respond(
  1941  		resp,
  1942  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1943  		autorest.ByUnmarshallingJSON(&result),
  1944  		autorest.ByClosing())
  1945  	result.Response = autorest.Response{Response: resp}
  1946  	return
  1947  }
  1948  
  1949  // GetIterationPerformance sends the get iteration performance request.
  1950  // Parameters:
  1951  // projectID - the id of the project the iteration belongs to.
  1952  // iterationID - the id of the iteration to get.
  1953  // threshold - the threshold used to determine true predictions.
  1954  // overlapThreshold - if applicable, the bounding box overlap threshold used to determine true predictions.
  1955  func (client BaseClient) GetIterationPerformance(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, threshold *float64, overlapThreshold *float64) (result IterationPerformance, err error) {
  1956  	if tracing.IsEnabled() {
  1957  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIterationPerformance")
  1958  		defer func() {
  1959  			sc := -1
  1960  			if result.Response.Response != nil {
  1961  				sc = result.Response.Response.StatusCode
  1962  			}
  1963  			tracing.EndSpan(ctx, sc, err)
  1964  		}()
  1965  	}
  1966  	req, err := client.GetIterationPerformancePreparer(ctx, projectID, iterationID, threshold, overlapThreshold)
  1967  	if err != nil {
  1968  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", nil, "Failure preparing request")
  1969  		return
  1970  	}
  1971  
  1972  	resp, err := client.GetIterationPerformanceSender(req)
  1973  	if err != nil {
  1974  		result.Response = autorest.Response{Response: resp}
  1975  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", resp, "Failure sending request")
  1976  		return
  1977  	}
  1978  
  1979  	result, err = client.GetIterationPerformanceResponder(resp)
  1980  	if err != nil {
  1981  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", resp, "Failure responding to request")
  1982  		return
  1983  	}
  1984  
  1985  	return
  1986  }
  1987  
  1988  // GetIterationPerformancePreparer prepares the GetIterationPerformance request.
  1989  func (client BaseClient) GetIterationPerformancePreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, threshold *float64, overlapThreshold *float64) (*http.Request, error) {
  1990  	urlParameters := map[string]interface{}{
  1991  		"Endpoint": client.Endpoint,
  1992  	}
  1993  
  1994  	pathParameters := map[string]interface{}{
  1995  		"iterationId": autorest.Encode("path", iterationID),
  1996  		"projectId":   autorest.Encode("path", projectID),
  1997  	}
  1998  
  1999  	queryParameters := map[string]interface{}{}
  2000  	if threshold != nil {
  2001  		queryParameters["threshold"] = autorest.Encode("query", *threshold)
  2002  	}
  2003  	if overlapThreshold != nil {
  2004  		queryParameters["overlapThreshold"] = autorest.Encode("query", *overlapThreshold)
  2005  	}
  2006  
  2007  	preparer := autorest.CreatePreparer(
  2008  		autorest.AsGet(),
  2009  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2010  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance", pathParameters),
  2011  		autorest.WithQueryParameters(queryParameters),
  2012  		autorest.WithHeader("Training-Key", client.APIKey))
  2013  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2014  }
  2015  
  2016  // GetIterationPerformanceSender sends the GetIterationPerformance request. The method will close the
  2017  // http.Response Body if it receives an error.
  2018  func (client BaseClient) GetIterationPerformanceSender(req *http.Request) (*http.Response, error) {
  2019  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2020  }
  2021  
  2022  // GetIterationPerformanceResponder handles the response to the GetIterationPerformance request. The method always
  2023  // closes the http.Response Body.
  2024  func (client BaseClient) GetIterationPerformanceResponder(resp *http.Response) (result IterationPerformance, err error) {
  2025  	err = autorest.Respond(
  2026  		resp,
  2027  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2028  		autorest.ByUnmarshallingJSON(&result),
  2029  		autorest.ByClosing())
  2030  	result.Response = autorest.Response{Response: resp}
  2031  	return
  2032  }
  2033  
  2034  // GetIterations sends the get iterations request.
  2035  // Parameters:
  2036  // projectID - the project id.
  2037  func (client BaseClient) GetIterations(ctx context.Context, projectID uuid.UUID) (result ListIteration, err error) {
  2038  	if tracing.IsEnabled() {
  2039  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIterations")
  2040  		defer func() {
  2041  			sc := -1
  2042  			if result.Response.Response != nil {
  2043  				sc = result.Response.Response.StatusCode
  2044  			}
  2045  			tracing.EndSpan(ctx, sc, err)
  2046  		}()
  2047  	}
  2048  	req, err := client.GetIterationsPreparer(ctx, projectID)
  2049  	if err != nil {
  2050  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", nil, "Failure preparing request")
  2051  		return
  2052  	}
  2053  
  2054  	resp, err := client.GetIterationsSender(req)
  2055  	if err != nil {
  2056  		result.Response = autorest.Response{Response: resp}
  2057  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", resp, "Failure sending request")
  2058  		return
  2059  	}
  2060  
  2061  	result, err = client.GetIterationsResponder(resp)
  2062  	if err != nil {
  2063  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", resp, "Failure responding to request")
  2064  		return
  2065  	}
  2066  
  2067  	return
  2068  }
  2069  
  2070  // GetIterationsPreparer prepares the GetIterations request.
  2071  func (client BaseClient) GetIterationsPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  2072  	urlParameters := map[string]interface{}{
  2073  		"Endpoint": client.Endpoint,
  2074  	}
  2075  
  2076  	pathParameters := map[string]interface{}{
  2077  		"projectId": autorest.Encode("path", projectID),
  2078  	}
  2079  
  2080  	preparer := autorest.CreatePreparer(
  2081  		autorest.AsGet(),
  2082  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2083  		autorest.WithPathParameters("/projects/{projectId}/iterations", pathParameters),
  2084  		autorest.WithHeader("Training-Key", client.APIKey))
  2085  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2086  }
  2087  
  2088  // GetIterationsSender sends the GetIterations request. The method will close the
  2089  // http.Response Body if it receives an error.
  2090  func (client BaseClient) GetIterationsSender(req *http.Request) (*http.Response, error) {
  2091  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2092  }
  2093  
  2094  // GetIterationsResponder handles the response to the GetIterations request. The method always
  2095  // closes the http.Response Body.
  2096  func (client BaseClient) GetIterationsResponder(resp *http.Response) (result ListIteration, err error) {
  2097  	err = autorest.Respond(
  2098  		resp,
  2099  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2100  		autorest.ByUnmarshallingJSON(&result.Value),
  2101  		autorest.ByClosing())
  2102  	result.Response = autorest.Response{Response: resp}
  2103  	return
  2104  }
  2105  
  2106  // GetProject sends the get project request.
  2107  // Parameters:
  2108  // projectID - the id of the project to get.
  2109  func (client BaseClient) GetProject(ctx context.Context, projectID uuid.UUID) (result Project, err error) {
  2110  	if tracing.IsEnabled() {
  2111  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetProject")
  2112  		defer func() {
  2113  			sc := -1
  2114  			if result.Response.Response != nil {
  2115  				sc = result.Response.Response.StatusCode
  2116  			}
  2117  			tracing.EndSpan(ctx, sc, err)
  2118  		}()
  2119  	}
  2120  	req, err := client.GetProjectPreparer(ctx, projectID)
  2121  	if err != nil {
  2122  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", nil, "Failure preparing request")
  2123  		return
  2124  	}
  2125  
  2126  	resp, err := client.GetProjectSender(req)
  2127  	if err != nil {
  2128  		result.Response = autorest.Response{Response: resp}
  2129  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", resp, "Failure sending request")
  2130  		return
  2131  	}
  2132  
  2133  	result, err = client.GetProjectResponder(resp)
  2134  	if err != nil {
  2135  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", resp, "Failure responding to request")
  2136  		return
  2137  	}
  2138  
  2139  	return
  2140  }
  2141  
  2142  // GetProjectPreparer prepares the GetProject request.
  2143  func (client BaseClient) GetProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  2144  	urlParameters := map[string]interface{}{
  2145  		"Endpoint": client.Endpoint,
  2146  	}
  2147  
  2148  	pathParameters := map[string]interface{}{
  2149  		"projectId": autorest.Encode("path", projectID),
  2150  	}
  2151  
  2152  	preparer := autorest.CreatePreparer(
  2153  		autorest.AsGet(),
  2154  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2155  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  2156  		autorest.WithHeader("Training-Key", client.APIKey))
  2157  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2158  }
  2159  
  2160  // GetProjectSender sends the GetProject request. The method will close the
  2161  // http.Response Body if it receives an error.
  2162  func (client BaseClient) GetProjectSender(req *http.Request) (*http.Response, error) {
  2163  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2164  }
  2165  
  2166  // GetProjectResponder handles the response to the GetProject request. The method always
  2167  // closes the http.Response Body.
  2168  func (client BaseClient) GetProjectResponder(resp *http.Response) (result Project, err error) {
  2169  	err = autorest.Respond(
  2170  		resp,
  2171  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2172  		autorest.ByUnmarshallingJSON(&result),
  2173  		autorest.ByClosing())
  2174  	result.Response = autorest.Response{Response: resp}
  2175  	return
  2176  }
  2177  
  2178  // GetProjects sends the get projects request.
  2179  func (client BaseClient) GetProjects(ctx context.Context) (result ListProject, err error) {
  2180  	if tracing.IsEnabled() {
  2181  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetProjects")
  2182  		defer func() {
  2183  			sc := -1
  2184  			if result.Response.Response != nil {
  2185  				sc = result.Response.Response.StatusCode
  2186  			}
  2187  			tracing.EndSpan(ctx, sc, err)
  2188  		}()
  2189  	}
  2190  	req, err := client.GetProjectsPreparer(ctx)
  2191  	if err != nil {
  2192  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", nil, "Failure preparing request")
  2193  		return
  2194  	}
  2195  
  2196  	resp, err := client.GetProjectsSender(req)
  2197  	if err != nil {
  2198  		result.Response = autorest.Response{Response: resp}
  2199  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", resp, "Failure sending request")
  2200  		return
  2201  	}
  2202  
  2203  	result, err = client.GetProjectsResponder(resp)
  2204  	if err != nil {
  2205  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", resp, "Failure responding to request")
  2206  		return
  2207  	}
  2208  
  2209  	return
  2210  }
  2211  
  2212  // GetProjectsPreparer prepares the GetProjects request.
  2213  func (client BaseClient) GetProjectsPreparer(ctx context.Context) (*http.Request, error) {
  2214  	urlParameters := map[string]interface{}{
  2215  		"Endpoint": client.Endpoint,
  2216  	}
  2217  
  2218  	preparer := autorest.CreatePreparer(
  2219  		autorest.AsGet(),
  2220  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2221  		autorest.WithPath("/projects"),
  2222  		autorest.WithHeader("Training-Key", client.APIKey))
  2223  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2224  }
  2225  
  2226  // GetProjectsSender sends the GetProjects request. The method will close the
  2227  // http.Response Body if it receives an error.
  2228  func (client BaseClient) GetProjectsSender(req *http.Request) (*http.Response, error) {
  2229  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2230  }
  2231  
  2232  // GetProjectsResponder handles the response to the GetProjects request. The method always
  2233  // closes the http.Response Body.
  2234  func (client BaseClient) GetProjectsResponder(resp *http.Response) (result ListProject, err error) {
  2235  	err = autorest.Respond(
  2236  		resp,
  2237  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2238  		autorest.ByUnmarshallingJSON(&result.Value),
  2239  		autorest.ByClosing())
  2240  	result.Response = autorest.Response{Response: resp}
  2241  	return
  2242  }
  2243  
  2244  // GetTag sends the get tag request.
  2245  // Parameters:
  2246  // projectID - the project this tag belongs to.
  2247  // tagID - the tag id.
  2248  // iterationID - the iteration to retrieve this tag from. Optional, defaults to current training set.
  2249  func (client BaseClient) GetTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, iterationID *uuid.UUID) (result Tag, err error) {
  2250  	if tracing.IsEnabled() {
  2251  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTag")
  2252  		defer func() {
  2253  			sc := -1
  2254  			if result.Response.Response != nil {
  2255  				sc = result.Response.Response.StatusCode
  2256  			}
  2257  			tracing.EndSpan(ctx, sc, err)
  2258  		}()
  2259  	}
  2260  	req, err := client.GetTagPreparer(ctx, projectID, tagID, iterationID)
  2261  	if err != nil {
  2262  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", nil, "Failure preparing request")
  2263  		return
  2264  	}
  2265  
  2266  	resp, err := client.GetTagSender(req)
  2267  	if err != nil {
  2268  		result.Response = autorest.Response{Response: resp}
  2269  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", resp, "Failure sending request")
  2270  		return
  2271  	}
  2272  
  2273  	result, err = client.GetTagResponder(resp)
  2274  	if err != nil {
  2275  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", resp, "Failure responding to request")
  2276  		return
  2277  	}
  2278  
  2279  	return
  2280  }
  2281  
  2282  // GetTagPreparer prepares the GetTag request.
  2283  func (client BaseClient) GetTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2284  	urlParameters := map[string]interface{}{
  2285  		"Endpoint": client.Endpoint,
  2286  	}
  2287  
  2288  	pathParameters := map[string]interface{}{
  2289  		"projectId": autorest.Encode("path", projectID),
  2290  		"tagId":     autorest.Encode("path", tagID),
  2291  	}
  2292  
  2293  	queryParameters := map[string]interface{}{}
  2294  	if iterationID != nil {
  2295  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2296  	}
  2297  
  2298  	preparer := autorest.CreatePreparer(
  2299  		autorest.AsGet(),
  2300  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2301  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  2302  		autorest.WithQueryParameters(queryParameters),
  2303  		autorest.WithHeader("Training-Key", client.APIKey))
  2304  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2305  }
  2306  
  2307  // GetTagSender sends the GetTag request. The method will close the
  2308  // http.Response Body if it receives an error.
  2309  func (client BaseClient) GetTagSender(req *http.Request) (*http.Response, error) {
  2310  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2311  }
  2312  
  2313  // GetTagResponder handles the response to the GetTag request. The method always
  2314  // closes the http.Response Body.
  2315  func (client BaseClient) GetTagResponder(resp *http.Response) (result Tag, err error) {
  2316  	err = autorest.Respond(
  2317  		resp,
  2318  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2319  		autorest.ByUnmarshallingJSON(&result),
  2320  		autorest.ByClosing())
  2321  	result.Response = autorest.Response{Response: resp}
  2322  	return
  2323  }
  2324  
  2325  // GetTaggedImageCount the filtering is on an and/or relationship. For example, if the provided tag ids are for the
  2326  // "Dog" and
  2327  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  2328  // Parameters:
  2329  // projectID - the project id.
  2330  // iterationID - the iteration id. Defaults to workspace.
  2331  // tagIds - a list of tags ids to filter the images to count. Defaults to all tags when null.
  2332  func (client BaseClient) GetTaggedImageCount(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string) (result Int32, err error) {
  2333  	if tracing.IsEnabled() {
  2334  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTaggedImageCount")
  2335  		defer func() {
  2336  			sc := -1
  2337  			if result.Response.Response != nil {
  2338  				sc = result.Response.Response.StatusCode
  2339  			}
  2340  			tracing.EndSpan(ctx, sc, err)
  2341  		}()
  2342  	}
  2343  	req, err := client.GetTaggedImageCountPreparer(ctx, projectID, iterationID, tagIds)
  2344  	if err != nil {
  2345  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", nil, "Failure preparing request")
  2346  		return
  2347  	}
  2348  
  2349  	resp, err := client.GetTaggedImageCountSender(req)
  2350  	if err != nil {
  2351  		result.Response = autorest.Response{Response: resp}
  2352  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", resp, "Failure sending request")
  2353  		return
  2354  	}
  2355  
  2356  	result, err = client.GetTaggedImageCountResponder(resp)
  2357  	if err != nil {
  2358  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", resp, "Failure responding to request")
  2359  		return
  2360  	}
  2361  
  2362  	return
  2363  }
  2364  
  2365  // GetTaggedImageCountPreparer prepares the GetTaggedImageCount request.
  2366  func (client BaseClient) GetTaggedImageCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string) (*http.Request, error) {
  2367  	urlParameters := map[string]interface{}{
  2368  		"Endpoint": client.Endpoint,
  2369  	}
  2370  
  2371  	pathParameters := map[string]interface{}{
  2372  		"projectId": autorest.Encode("path", projectID),
  2373  	}
  2374  
  2375  	queryParameters := map[string]interface{}{}
  2376  	if iterationID != nil {
  2377  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2378  	}
  2379  	if tagIds != nil && len(tagIds) > 0 {
  2380  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  2381  	}
  2382  
  2383  	preparer := autorest.CreatePreparer(
  2384  		autorest.AsGet(),
  2385  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2386  		autorest.WithPathParameters("/projects/{projectId}/images/tagged/count", pathParameters),
  2387  		autorest.WithQueryParameters(queryParameters),
  2388  		autorest.WithHeader("Training-Key", client.APIKey))
  2389  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2390  }
  2391  
  2392  // GetTaggedImageCountSender sends the GetTaggedImageCount request. The method will close the
  2393  // http.Response Body if it receives an error.
  2394  func (client BaseClient) GetTaggedImageCountSender(req *http.Request) (*http.Response, error) {
  2395  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2396  }
  2397  
  2398  // GetTaggedImageCountResponder handles the response to the GetTaggedImageCount request. The method always
  2399  // closes the http.Response Body.
  2400  func (client BaseClient) GetTaggedImageCountResponder(resp *http.Response) (result Int32, err error) {
  2401  	err = autorest.Respond(
  2402  		resp,
  2403  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2404  		autorest.ByUnmarshallingJSON(&result.Value),
  2405  		autorest.ByClosing())
  2406  	result.Response = autorest.Response{Response: resp}
  2407  	return
  2408  }
  2409  
  2410  // GetTaggedImages this API supports batching and range selection. By default it will only return first 50 images
  2411  // matching images.
  2412  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  2413  // The filtering is on an and/or relationship. For example, if the provided tag ids are for the "Dog" and
  2414  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  2415  // Parameters:
  2416  // projectID - the project id.
  2417  // iterationID - the iteration id. Defaults to workspace.
  2418  // tagIds - a list of tags ids to filter the images. Defaults to all tagged images when null. Limited to 20.
  2419  // orderBy - the ordering. Defaults to newest.
  2420  // take - maximum number of images to return. Defaults to 50, limited to 256.
  2421  // skip - number of images to skip before beginning the image batch. Defaults to 0.
  2422  func (client BaseClient) GetTaggedImages(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (result ListImage, err error) {
  2423  	if tracing.IsEnabled() {
  2424  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTaggedImages")
  2425  		defer func() {
  2426  			sc := -1
  2427  			if result.Response.Response != nil {
  2428  				sc = result.Response.Response.StatusCode
  2429  			}
  2430  			tracing.EndSpan(ctx, sc, err)
  2431  		}()
  2432  	}
  2433  	req, err := client.GetTaggedImagesPreparer(ctx, projectID, iterationID, tagIds, orderBy, take, skip)
  2434  	if err != nil {
  2435  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", nil, "Failure preparing request")
  2436  		return
  2437  	}
  2438  
  2439  	resp, err := client.GetTaggedImagesSender(req)
  2440  	if err != nil {
  2441  		result.Response = autorest.Response{Response: resp}
  2442  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", resp, "Failure sending request")
  2443  		return
  2444  	}
  2445  
  2446  	result, err = client.GetTaggedImagesResponder(resp)
  2447  	if err != nil {
  2448  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", resp, "Failure responding to request")
  2449  		return
  2450  	}
  2451  
  2452  	return
  2453  }
  2454  
  2455  // GetTaggedImagesPreparer prepares the GetTaggedImages request.
  2456  func (client BaseClient) GetTaggedImagesPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (*http.Request, error) {
  2457  	urlParameters := map[string]interface{}{
  2458  		"Endpoint": client.Endpoint,
  2459  	}
  2460  
  2461  	pathParameters := map[string]interface{}{
  2462  		"projectId": autorest.Encode("path", projectID),
  2463  	}
  2464  
  2465  	queryParameters := map[string]interface{}{}
  2466  	if iterationID != nil {
  2467  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2468  	}
  2469  	if tagIds != nil && len(tagIds) > 0 {
  2470  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  2471  	}
  2472  	if len(string(orderBy)) > 0 {
  2473  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  2474  	}
  2475  	if take != nil {
  2476  		queryParameters["take"] = autorest.Encode("query", *take)
  2477  	} else {
  2478  		queryParameters["take"] = autorest.Encode("query", 50)
  2479  	}
  2480  	if skip != nil {
  2481  		queryParameters["skip"] = autorest.Encode("query", *skip)
  2482  	} else {
  2483  		queryParameters["skip"] = autorest.Encode("query", 0)
  2484  	}
  2485  
  2486  	preparer := autorest.CreatePreparer(
  2487  		autorest.AsGet(),
  2488  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2489  		autorest.WithPathParameters("/projects/{projectId}/images/tagged", pathParameters),
  2490  		autorest.WithQueryParameters(queryParameters),
  2491  		autorest.WithHeader("Training-Key", client.APIKey))
  2492  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2493  }
  2494  
  2495  // GetTaggedImagesSender sends the GetTaggedImages request. The method will close the
  2496  // http.Response Body if it receives an error.
  2497  func (client BaseClient) GetTaggedImagesSender(req *http.Request) (*http.Response, error) {
  2498  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2499  }
  2500  
  2501  // GetTaggedImagesResponder handles the response to the GetTaggedImages request. The method always
  2502  // closes the http.Response Body.
  2503  func (client BaseClient) GetTaggedImagesResponder(resp *http.Response) (result ListImage, err error) {
  2504  	err = autorest.Respond(
  2505  		resp,
  2506  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2507  		autorest.ByUnmarshallingJSON(&result.Value),
  2508  		autorest.ByClosing())
  2509  	result.Response = autorest.Response{Response: resp}
  2510  	return
  2511  }
  2512  
  2513  // GetTags sends the get tags request.
  2514  // Parameters:
  2515  // projectID - the project id.
  2516  // iterationID - the iteration id. Defaults to workspace.
  2517  func (client BaseClient) GetTags(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (result ListTag, err error) {
  2518  	if tracing.IsEnabled() {
  2519  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTags")
  2520  		defer func() {
  2521  			sc := -1
  2522  			if result.Response.Response != nil {
  2523  				sc = result.Response.Response.StatusCode
  2524  			}
  2525  			tracing.EndSpan(ctx, sc, err)
  2526  		}()
  2527  	}
  2528  	req, err := client.GetTagsPreparer(ctx, projectID, iterationID)
  2529  	if err != nil {
  2530  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", nil, "Failure preparing request")
  2531  		return
  2532  	}
  2533  
  2534  	resp, err := client.GetTagsSender(req)
  2535  	if err != nil {
  2536  		result.Response = autorest.Response{Response: resp}
  2537  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", resp, "Failure sending request")
  2538  		return
  2539  	}
  2540  
  2541  	result, err = client.GetTagsResponder(resp)
  2542  	if err != nil {
  2543  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", resp, "Failure responding to request")
  2544  		return
  2545  	}
  2546  
  2547  	return
  2548  }
  2549  
  2550  // GetTagsPreparer prepares the GetTags request.
  2551  func (client BaseClient) GetTagsPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2552  	urlParameters := map[string]interface{}{
  2553  		"Endpoint": client.Endpoint,
  2554  	}
  2555  
  2556  	pathParameters := map[string]interface{}{
  2557  		"projectId": autorest.Encode("path", projectID),
  2558  	}
  2559  
  2560  	queryParameters := map[string]interface{}{}
  2561  	if iterationID != nil {
  2562  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2563  	}
  2564  
  2565  	preparer := autorest.CreatePreparer(
  2566  		autorest.AsGet(),
  2567  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2568  		autorest.WithPathParameters("/projects/{projectId}/tags", pathParameters),
  2569  		autorest.WithQueryParameters(queryParameters),
  2570  		autorest.WithHeader("Training-Key", client.APIKey))
  2571  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2572  }
  2573  
  2574  // GetTagsSender sends the GetTags request. The method will close the
  2575  // http.Response Body if it receives an error.
  2576  func (client BaseClient) GetTagsSender(req *http.Request) (*http.Response, error) {
  2577  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2578  }
  2579  
  2580  // GetTagsResponder handles the response to the GetTags request. The method always
  2581  // closes the http.Response Body.
  2582  func (client BaseClient) GetTagsResponder(resp *http.Response) (result ListTag, err error) {
  2583  	err = autorest.Respond(
  2584  		resp,
  2585  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2586  		autorest.ByUnmarshallingJSON(&result.Value),
  2587  		autorest.ByClosing())
  2588  	result.Response = autorest.Response{Response: resp}
  2589  	return
  2590  }
  2591  
  2592  // GetUntaggedImageCount this API returns the images which have no tags for a given project and optionally an
  2593  // iteration. If no iteration is specified the
  2594  // current workspace is used.
  2595  // Parameters:
  2596  // projectID - the project id.
  2597  // iterationID - the iteration id. Defaults to workspace.
  2598  func (client BaseClient) GetUntaggedImageCount(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (result Int32, err error) {
  2599  	if tracing.IsEnabled() {
  2600  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetUntaggedImageCount")
  2601  		defer func() {
  2602  			sc := -1
  2603  			if result.Response.Response != nil {
  2604  				sc = result.Response.Response.StatusCode
  2605  			}
  2606  			tracing.EndSpan(ctx, sc, err)
  2607  		}()
  2608  	}
  2609  	req, err := client.GetUntaggedImageCountPreparer(ctx, projectID, iterationID)
  2610  	if err != nil {
  2611  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", nil, "Failure preparing request")
  2612  		return
  2613  	}
  2614  
  2615  	resp, err := client.GetUntaggedImageCountSender(req)
  2616  	if err != nil {
  2617  		result.Response = autorest.Response{Response: resp}
  2618  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", resp, "Failure sending request")
  2619  		return
  2620  	}
  2621  
  2622  	result, err = client.GetUntaggedImageCountResponder(resp)
  2623  	if err != nil {
  2624  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", resp, "Failure responding to request")
  2625  		return
  2626  	}
  2627  
  2628  	return
  2629  }
  2630  
  2631  // GetUntaggedImageCountPreparer prepares the GetUntaggedImageCount request.
  2632  func (client BaseClient) GetUntaggedImageCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2633  	urlParameters := map[string]interface{}{
  2634  		"Endpoint": client.Endpoint,
  2635  	}
  2636  
  2637  	pathParameters := map[string]interface{}{
  2638  		"projectId": autorest.Encode("path", projectID),
  2639  	}
  2640  
  2641  	queryParameters := map[string]interface{}{}
  2642  	if iterationID != nil {
  2643  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2644  	}
  2645  
  2646  	preparer := autorest.CreatePreparer(
  2647  		autorest.AsGet(),
  2648  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2649  		autorest.WithPathParameters("/projects/{projectId}/images/untagged/count", pathParameters),
  2650  		autorest.WithQueryParameters(queryParameters),
  2651  		autorest.WithHeader("Training-Key", client.APIKey))
  2652  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2653  }
  2654  
  2655  // GetUntaggedImageCountSender sends the GetUntaggedImageCount request. The method will close the
  2656  // http.Response Body if it receives an error.
  2657  func (client BaseClient) GetUntaggedImageCountSender(req *http.Request) (*http.Response, error) {
  2658  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2659  }
  2660  
  2661  // GetUntaggedImageCountResponder handles the response to the GetUntaggedImageCount request. The method always
  2662  // closes the http.Response Body.
  2663  func (client BaseClient) GetUntaggedImageCountResponder(resp *http.Response) (result Int32, err error) {
  2664  	err = autorest.Respond(
  2665  		resp,
  2666  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2667  		autorest.ByUnmarshallingJSON(&result.Value),
  2668  		autorest.ByClosing())
  2669  	result.Response = autorest.Response{Response: resp}
  2670  	return
  2671  }
  2672  
  2673  // GetUntaggedImages this API supports batching and range selection. By default it will only return first 50 images
  2674  // matching images.
  2675  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  2676  // Parameters:
  2677  // projectID - the project id.
  2678  // iterationID - the iteration id. Defaults to workspace.
  2679  // orderBy - the ordering. Defaults to newest.
  2680  // take - maximum number of images to return. Defaults to 50, limited to 256.
  2681  // skip - number of images to skip before beginning the image batch. Defaults to 0.
  2682  func (client BaseClient) GetUntaggedImages(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, orderBy string, take *int32, skip *int32) (result ListImage, err error) {
  2683  	if tracing.IsEnabled() {
  2684  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetUntaggedImages")
  2685  		defer func() {
  2686  			sc := -1
  2687  			if result.Response.Response != nil {
  2688  				sc = result.Response.Response.StatusCode
  2689  			}
  2690  			tracing.EndSpan(ctx, sc, err)
  2691  		}()
  2692  	}
  2693  	req, err := client.GetUntaggedImagesPreparer(ctx, projectID, iterationID, orderBy, take, skip)
  2694  	if err != nil {
  2695  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", nil, "Failure preparing request")
  2696  		return
  2697  	}
  2698  
  2699  	resp, err := client.GetUntaggedImagesSender(req)
  2700  	if err != nil {
  2701  		result.Response = autorest.Response{Response: resp}
  2702  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", resp, "Failure sending request")
  2703  		return
  2704  	}
  2705  
  2706  	result, err = client.GetUntaggedImagesResponder(resp)
  2707  	if err != nil {
  2708  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", resp, "Failure responding to request")
  2709  		return
  2710  	}
  2711  
  2712  	return
  2713  }
  2714  
  2715  // GetUntaggedImagesPreparer prepares the GetUntaggedImages request.
  2716  func (client BaseClient) GetUntaggedImagesPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, orderBy string, take *int32, skip *int32) (*http.Request, error) {
  2717  	urlParameters := map[string]interface{}{
  2718  		"Endpoint": client.Endpoint,
  2719  	}
  2720  
  2721  	pathParameters := map[string]interface{}{
  2722  		"projectId": autorest.Encode("path", projectID),
  2723  	}
  2724  
  2725  	queryParameters := map[string]interface{}{}
  2726  	if iterationID != nil {
  2727  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2728  	}
  2729  	if len(string(orderBy)) > 0 {
  2730  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  2731  	}
  2732  	if take != nil {
  2733  		queryParameters["take"] = autorest.Encode("query", *take)
  2734  	} else {
  2735  		queryParameters["take"] = autorest.Encode("query", 50)
  2736  	}
  2737  	if skip != nil {
  2738  		queryParameters["skip"] = autorest.Encode("query", *skip)
  2739  	} else {
  2740  		queryParameters["skip"] = autorest.Encode("query", 0)
  2741  	}
  2742  
  2743  	preparer := autorest.CreatePreparer(
  2744  		autorest.AsGet(),
  2745  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2746  		autorest.WithPathParameters("/projects/{projectId}/images/untagged", pathParameters),
  2747  		autorest.WithQueryParameters(queryParameters),
  2748  		autorest.WithHeader("Training-Key", client.APIKey))
  2749  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2750  }
  2751  
  2752  // GetUntaggedImagesSender sends the GetUntaggedImages request. The method will close the
  2753  // http.Response Body if it receives an error.
  2754  func (client BaseClient) GetUntaggedImagesSender(req *http.Request) (*http.Response, error) {
  2755  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2756  }
  2757  
  2758  // GetUntaggedImagesResponder handles the response to the GetUntaggedImages request. The method always
  2759  // closes the http.Response Body.
  2760  func (client BaseClient) GetUntaggedImagesResponder(resp *http.Response) (result ListImage, err error) {
  2761  	err = autorest.Respond(
  2762  		resp,
  2763  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2764  		autorest.ByUnmarshallingJSON(&result.Value),
  2765  		autorest.ByClosing())
  2766  	result.Response = autorest.Response{Response: resp}
  2767  	return
  2768  }
  2769  
  2770  // QueryPredictions sends the query predictions request.
  2771  // Parameters:
  2772  // projectID - the project id.
  2773  // query - parameters used to query the predictions. Limited to combining 2 tags.
  2774  func (client BaseClient) QueryPredictions(ctx context.Context, projectID uuid.UUID, query PredictionQueryToken) (result PredictionQueryResult, err error) {
  2775  	if tracing.IsEnabled() {
  2776  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QueryPredictions")
  2777  		defer func() {
  2778  			sc := -1
  2779  			if result.Response.Response != nil {
  2780  				sc = result.Response.Response.StatusCode
  2781  			}
  2782  			tracing.EndSpan(ctx, sc, err)
  2783  		}()
  2784  	}
  2785  	req, err := client.QueryPredictionsPreparer(ctx, projectID, query)
  2786  	if err != nil {
  2787  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", nil, "Failure preparing request")
  2788  		return
  2789  	}
  2790  
  2791  	resp, err := client.QueryPredictionsSender(req)
  2792  	if err != nil {
  2793  		result.Response = autorest.Response{Response: resp}
  2794  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", resp, "Failure sending request")
  2795  		return
  2796  	}
  2797  
  2798  	result, err = client.QueryPredictionsResponder(resp)
  2799  	if err != nil {
  2800  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", resp, "Failure responding to request")
  2801  		return
  2802  	}
  2803  
  2804  	return
  2805  }
  2806  
  2807  // QueryPredictionsPreparer prepares the QueryPredictions request.
  2808  func (client BaseClient) QueryPredictionsPreparer(ctx context.Context, projectID uuid.UUID, query PredictionQueryToken) (*http.Request, error) {
  2809  	urlParameters := map[string]interface{}{
  2810  		"Endpoint": client.Endpoint,
  2811  	}
  2812  
  2813  	pathParameters := map[string]interface{}{
  2814  		"projectId": autorest.Encode("path", projectID),
  2815  	}
  2816  
  2817  	preparer := autorest.CreatePreparer(
  2818  		autorest.AsContentType("application/json; charset=utf-8"),
  2819  		autorest.AsPost(),
  2820  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2821  		autorest.WithPathParameters("/projects/{projectId}/predictions/query", pathParameters),
  2822  		autorest.WithJSON(query),
  2823  		autorest.WithHeader("Training-Key", client.APIKey))
  2824  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2825  }
  2826  
  2827  // QueryPredictionsSender sends the QueryPredictions request. The method will close the
  2828  // http.Response Body if it receives an error.
  2829  func (client BaseClient) QueryPredictionsSender(req *http.Request) (*http.Response, error) {
  2830  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2831  }
  2832  
  2833  // QueryPredictionsResponder handles the response to the QueryPredictions request. The method always
  2834  // closes the http.Response Body.
  2835  func (client BaseClient) QueryPredictionsResponder(resp *http.Response) (result PredictionQueryResult, err error) {
  2836  	err = autorest.Respond(
  2837  		resp,
  2838  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2839  		autorest.ByUnmarshallingJSON(&result),
  2840  		autorest.ByClosing())
  2841  	result.Response = autorest.Response{Response: resp}
  2842  	return
  2843  }
  2844  
  2845  // QuickTestImage sends the quick test image request.
  2846  // Parameters:
  2847  // projectID - the project id.
  2848  // imageData - binary image data.
  2849  // iterationID - optional. Specifies the id of a particular iteration to evaluate against.
  2850  // The default iteration for the project will be used when not specified.
  2851  func (client BaseClient) QuickTestImage(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, iterationID *uuid.UUID) (result ImagePrediction, err error) {
  2852  	if tracing.IsEnabled() {
  2853  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuickTestImage")
  2854  		defer func() {
  2855  			sc := -1
  2856  			if result.Response.Response != nil {
  2857  				sc = result.Response.Response.StatusCode
  2858  			}
  2859  			tracing.EndSpan(ctx, sc, err)
  2860  		}()
  2861  	}
  2862  	req, err := client.QuickTestImagePreparer(ctx, projectID, imageData, iterationID)
  2863  	if err != nil {
  2864  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", nil, "Failure preparing request")
  2865  		return
  2866  	}
  2867  
  2868  	resp, err := client.QuickTestImageSender(req)
  2869  	if err != nil {
  2870  		result.Response = autorest.Response{Response: resp}
  2871  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", resp, "Failure sending request")
  2872  		return
  2873  	}
  2874  
  2875  	result, err = client.QuickTestImageResponder(resp)
  2876  	if err != nil {
  2877  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", resp, "Failure responding to request")
  2878  		return
  2879  	}
  2880  
  2881  	return
  2882  }
  2883  
  2884  // QuickTestImagePreparer prepares the QuickTestImage request.
  2885  func (client BaseClient) QuickTestImagePreparer(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, iterationID *uuid.UUID) (*http.Request, error) {
  2886  	urlParameters := map[string]interface{}{
  2887  		"Endpoint": client.Endpoint,
  2888  	}
  2889  
  2890  	pathParameters := map[string]interface{}{
  2891  		"projectId": autorest.Encode("path", projectID),
  2892  	}
  2893  
  2894  	queryParameters := map[string]interface{}{}
  2895  	if iterationID != nil {
  2896  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2897  	}
  2898  
  2899  	formDataParameters := map[string]interface{}{
  2900  		"imageData": imageData,
  2901  	}
  2902  
  2903  	preparer := autorest.CreatePreparer(
  2904  		autorest.AsPost(),
  2905  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2906  		autorest.WithPathParameters("/projects/{projectId}/quicktest/image", pathParameters),
  2907  		autorest.WithQueryParameters(queryParameters),
  2908  		autorest.WithMultiPartFormData(formDataParameters),
  2909  		autorest.WithHeader("Training-Key", client.APIKey))
  2910  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2911  }
  2912  
  2913  // QuickTestImageSender sends the QuickTestImage request. The method will close the
  2914  // http.Response Body if it receives an error.
  2915  func (client BaseClient) QuickTestImageSender(req *http.Request) (*http.Response, error) {
  2916  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2917  }
  2918  
  2919  // QuickTestImageResponder handles the response to the QuickTestImage request. The method always
  2920  // closes the http.Response Body.
  2921  func (client BaseClient) QuickTestImageResponder(resp *http.Response) (result ImagePrediction, err error) {
  2922  	err = autorest.Respond(
  2923  		resp,
  2924  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2925  		autorest.ByUnmarshallingJSON(&result),
  2926  		autorest.ByClosing())
  2927  	result.Response = autorest.Response{Response: resp}
  2928  	return
  2929  }
  2930  
  2931  // QuickTestImageURL sends the quick test image url request.
  2932  // Parameters:
  2933  // projectID - the project to evaluate against.
  2934  // imageURL - an {Iris.Web.Api.Models.ImageUrl} that contains the url of the image to be evaluated.
  2935  // iterationID - optional. Specifies the id of a particular iteration to evaluate against.
  2936  // The default iteration for the project will be used when not specified.
  2937  func (client BaseClient) QuickTestImageURL(ctx context.Context, projectID uuid.UUID, imageURL ImageURL, iterationID *uuid.UUID) (result ImagePrediction, err error) {
  2938  	if tracing.IsEnabled() {
  2939  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuickTestImageURL")
  2940  		defer func() {
  2941  			sc := -1
  2942  			if result.Response.Response != nil {
  2943  				sc = result.Response.Response.StatusCode
  2944  			}
  2945  			tracing.EndSpan(ctx, sc, err)
  2946  		}()
  2947  	}
  2948  	req, err := client.QuickTestImageURLPreparer(ctx, projectID, imageURL, iterationID)
  2949  	if err != nil {
  2950  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", nil, "Failure preparing request")
  2951  		return
  2952  	}
  2953  
  2954  	resp, err := client.QuickTestImageURLSender(req)
  2955  	if err != nil {
  2956  		result.Response = autorest.Response{Response: resp}
  2957  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", resp, "Failure sending request")
  2958  		return
  2959  	}
  2960  
  2961  	result, err = client.QuickTestImageURLResponder(resp)
  2962  	if err != nil {
  2963  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", resp, "Failure responding to request")
  2964  		return
  2965  	}
  2966  
  2967  	return
  2968  }
  2969  
  2970  // QuickTestImageURLPreparer prepares the QuickTestImageURL request.
  2971  func (client BaseClient) QuickTestImageURLPreparer(ctx context.Context, projectID uuid.UUID, imageURL ImageURL, iterationID *uuid.UUID) (*http.Request, error) {
  2972  	urlParameters := map[string]interface{}{
  2973  		"Endpoint": client.Endpoint,
  2974  	}
  2975  
  2976  	pathParameters := map[string]interface{}{
  2977  		"projectId": autorest.Encode("path", projectID),
  2978  	}
  2979  
  2980  	queryParameters := map[string]interface{}{}
  2981  	if iterationID != nil {
  2982  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2983  	}
  2984  
  2985  	preparer := autorest.CreatePreparer(
  2986  		autorest.AsContentType("application/json; charset=utf-8"),
  2987  		autorest.AsPost(),
  2988  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  2989  		autorest.WithPathParameters("/projects/{projectId}/quicktest/url", pathParameters),
  2990  		autorest.WithJSON(imageURL),
  2991  		autorest.WithQueryParameters(queryParameters),
  2992  		autorest.WithHeader("Training-Key", client.APIKey))
  2993  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2994  }
  2995  
  2996  // QuickTestImageURLSender sends the QuickTestImageURL request. The method will close the
  2997  // http.Response Body if it receives an error.
  2998  func (client BaseClient) QuickTestImageURLSender(req *http.Request) (*http.Response, error) {
  2999  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3000  }
  3001  
  3002  // QuickTestImageURLResponder handles the response to the QuickTestImageURL request. The method always
  3003  // closes the http.Response Body.
  3004  func (client BaseClient) QuickTestImageURLResponder(resp *http.Response) (result ImagePrediction, err error) {
  3005  	err = autorest.Respond(
  3006  		resp,
  3007  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3008  		autorest.ByUnmarshallingJSON(&result),
  3009  		autorest.ByClosing())
  3010  	result.Response = autorest.Response{Response: resp}
  3011  	return
  3012  }
  3013  
  3014  // TrainProject sends the train project request.
  3015  // Parameters:
  3016  // projectID - the project id.
  3017  func (client BaseClient) TrainProject(ctx context.Context, projectID uuid.UUID) (result Iteration, err error) {
  3018  	if tracing.IsEnabled() {
  3019  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.TrainProject")
  3020  		defer func() {
  3021  			sc := -1
  3022  			if result.Response.Response != nil {
  3023  				sc = result.Response.Response.StatusCode
  3024  			}
  3025  			tracing.EndSpan(ctx, sc, err)
  3026  		}()
  3027  	}
  3028  	req, err := client.TrainProjectPreparer(ctx, projectID)
  3029  	if err != nil {
  3030  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", nil, "Failure preparing request")
  3031  		return
  3032  	}
  3033  
  3034  	resp, err := client.TrainProjectSender(req)
  3035  	if err != nil {
  3036  		result.Response = autorest.Response{Response: resp}
  3037  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", resp, "Failure sending request")
  3038  		return
  3039  	}
  3040  
  3041  	result, err = client.TrainProjectResponder(resp)
  3042  	if err != nil {
  3043  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", resp, "Failure responding to request")
  3044  		return
  3045  	}
  3046  
  3047  	return
  3048  }
  3049  
  3050  // TrainProjectPreparer prepares the TrainProject request.
  3051  func (client BaseClient) TrainProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  3052  	urlParameters := map[string]interface{}{
  3053  		"Endpoint": client.Endpoint,
  3054  	}
  3055  
  3056  	pathParameters := map[string]interface{}{
  3057  		"projectId": autorest.Encode("path", projectID),
  3058  	}
  3059  
  3060  	preparer := autorest.CreatePreparer(
  3061  		autorest.AsPost(),
  3062  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  3063  		autorest.WithPathParameters("/projects/{projectId}/train", pathParameters),
  3064  		autorest.WithHeader("Training-Key", client.APIKey))
  3065  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3066  }
  3067  
  3068  // TrainProjectSender sends the TrainProject request. The method will close the
  3069  // http.Response Body if it receives an error.
  3070  func (client BaseClient) TrainProjectSender(req *http.Request) (*http.Response, error) {
  3071  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3072  }
  3073  
  3074  // TrainProjectResponder handles the response to the TrainProject request. The method always
  3075  // closes the http.Response Body.
  3076  func (client BaseClient) TrainProjectResponder(resp *http.Response) (result Iteration, err error) {
  3077  	err = autorest.Respond(
  3078  		resp,
  3079  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3080  		autorest.ByUnmarshallingJSON(&result),
  3081  		autorest.ByClosing())
  3082  	result.Response = autorest.Response{Response: resp}
  3083  	return
  3084  }
  3085  
  3086  // UpdateIteration sends the update iteration request.
  3087  // Parameters:
  3088  // projectID - project id.
  3089  // iterationID - iteration id.
  3090  // updatedIteration - the updated iteration model.
  3091  func (client BaseClient) UpdateIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, updatedIteration Iteration) (result Iteration, err error) {
  3092  	if tracing.IsEnabled() {
  3093  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateIteration")
  3094  		defer func() {
  3095  			sc := -1
  3096  			if result.Response.Response != nil {
  3097  				sc = result.Response.Response.StatusCode
  3098  			}
  3099  			tracing.EndSpan(ctx, sc, err)
  3100  		}()
  3101  	}
  3102  	req, err := client.UpdateIterationPreparer(ctx, projectID, iterationID, updatedIteration)
  3103  	if err != nil {
  3104  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", nil, "Failure preparing request")
  3105  		return
  3106  	}
  3107  
  3108  	resp, err := client.UpdateIterationSender(req)
  3109  	if err != nil {
  3110  		result.Response = autorest.Response{Response: resp}
  3111  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", resp, "Failure sending request")
  3112  		return
  3113  	}
  3114  
  3115  	result, err = client.UpdateIterationResponder(resp)
  3116  	if err != nil {
  3117  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", resp, "Failure responding to request")
  3118  		return
  3119  	}
  3120  
  3121  	return
  3122  }
  3123  
  3124  // UpdateIterationPreparer prepares the UpdateIteration request.
  3125  func (client BaseClient) UpdateIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, updatedIteration Iteration) (*http.Request, error) {
  3126  	urlParameters := map[string]interface{}{
  3127  		"Endpoint": client.Endpoint,
  3128  	}
  3129  
  3130  	pathParameters := map[string]interface{}{
  3131  		"iterationId": autorest.Encode("path", iterationID),
  3132  		"projectId":   autorest.Encode("path", projectID),
  3133  	}
  3134  
  3135  	updatedIteration.ID = nil
  3136  	updatedIteration.Status = nil
  3137  	updatedIteration.Created = nil
  3138  	updatedIteration.LastModified = nil
  3139  	updatedIteration.TrainedAt = nil
  3140  	updatedIteration.ProjectID = nil
  3141  	updatedIteration.Exportable = nil
  3142  	updatedIteration.DomainID = nil
  3143  	updatedIteration.ClassificationType = ""
  3144  	preparer := autorest.CreatePreparer(
  3145  		autorest.AsContentType("application/json; charset=utf-8"),
  3146  		autorest.AsPatch(),
  3147  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  3148  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
  3149  		autorest.WithJSON(updatedIteration),
  3150  		autorest.WithHeader("Training-Key", client.APIKey))
  3151  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3152  }
  3153  
  3154  // UpdateIterationSender sends the UpdateIteration request. The method will close the
  3155  // http.Response Body if it receives an error.
  3156  func (client BaseClient) UpdateIterationSender(req *http.Request) (*http.Response, error) {
  3157  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3158  }
  3159  
  3160  // UpdateIterationResponder handles the response to the UpdateIteration request. The method always
  3161  // closes the http.Response Body.
  3162  func (client BaseClient) UpdateIterationResponder(resp *http.Response) (result Iteration, err error) {
  3163  	err = autorest.Respond(
  3164  		resp,
  3165  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3166  		autorest.ByUnmarshallingJSON(&result),
  3167  		autorest.ByClosing())
  3168  	result.Response = autorest.Response{Response: resp}
  3169  	return
  3170  }
  3171  
  3172  // UpdateProject sends the update project request.
  3173  // Parameters:
  3174  // projectID - the id of the project to update.
  3175  // updatedProject - the updated project model.
  3176  func (client BaseClient) UpdateProject(ctx context.Context, projectID uuid.UUID, updatedProject Project) (result Project, err error) {
  3177  	if tracing.IsEnabled() {
  3178  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateProject")
  3179  		defer func() {
  3180  			sc := -1
  3181  			if result.Response.Response != nil {
  3182  				sc = result.Response.Response.StatusCode
  3183  			}
  3184  			tracing.EndSpan(ctx, sc, err)
  3185  		}()
  3186  	}
  3187  	req, err := client.UpdateProjectPreparer(ctx, projectID, updatedProject)
  3188  	if err != nil {
  3189  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", nil, "Failure preparing request")
  3190  		return
  3191  	}
  3192  
  3193  	resp, err := client.UpdateProjectSender(req)
  3194  	if err != nil {
  3195  		result.Response = autorest.Response{Response: resp}
  3196  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", resp, "Failure sending request")
  3197  		return
  3198  	}
  3199  
  3200  	result, err = client.UpdateProjectResponder(resp)
  3201  	if err != nil {
  3202  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", resp, "Failure responding to request")
  3203  		return
  3204  	}
  3205  
  3206  	return
  3207  }
  3208  
  3209  // UpdateProjectPreparer prepares the UpdateProject request.
  3210  func (client BaseClient) UpdateProjectPreparer(ctx context.Context, projectID uuid.UUID, updatedProject Project) (*http.Request, error) {
  3211  	urlParameters := map[string]interface{}{
  3212  		"Endpoint": client.Endpoint,
  3213  	}
  3214  
  3215  	pathParameters := map[string]interface{}{
  3216  		"projectId": autorest.Encode("path", projectID),
  3217  	}
  3218  
  3219  	updatedProject.ID = nil
  3220  	updatedProject.Created = nil
  3221  	updatedProject.LastModified = nil
  3222  	updatedProject.ThumbnailURI = nil
  3223  	preparer := autorest.CreatePreparer(
  3224  		autorest.AsContentType("application/json; charset=utf-8"),
  3225  		autorest.AsPatch(),
  3226  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  3227  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  3228  		autorest.WithJSON(updatedProject),
  3229  		autorest.WithHeader("Training-Key", client.APIKey))
  3230  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3231  }
  3232  
  3233  // UpdateProjectSender sends the UpdateProject request. The method will close the
  3234  // http.Response Body if it receives an error.
  3235  func (client BaseClient) UpdateProjectSender(req *http.Request) (*http.Response, error) {
  3236  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3237  }
  3238  
  3239  // UpdateProjectResponder handles the response to the UpdateProject request. The method always
  3240  // closes the http.Response Body.
  3241  func (client BaseClient) UpdateProjectResponder(resp *http.Response) (result Project, err error) {
  3242  	err = autorest.Respond(
  3243  		resp,
  3244  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3245  		autorest.ByUnmarshallingJSON(&result),
  3246  		autorest.ByClosing())
  3247  	result.Response = autorest.Response{Response: resp}
  3248  	return
  3249  }
  3250  
  3251  // UpdateTag sends the update tag request.
  3252  // Parameters:
  3253  // projectID - the project id.
  3254  // tagID - the id of the target tag.
  3255  // updatedTag - the updated tag model.
  3256  func (client BaseClient) UpdateTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, updatedTag Tag) (result Tag, err error) {
  3257  	if tracing.IsEnabled() {
  3258  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateTag")
  3259  		defer func() {
  3260  			sc := -1
  3261  			if result.Response.Response != nil {
  3262  				sc = result.Response.Response.StatusCode
  3263  			}
  3264  			tracing.EndSpan(ctx, sc, err)
  3265  		}()
  3266  	}
  3267  	req, err := client.UpdateTagPreparer(ctx, projectID, tagID, updatedTag)
  3268  	if err != nil {
  3269  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", nil, "Failure preparing request")
  3270  		return
  3271  	}
  3272  
  3273  	resp, err := client.UpdateTagSender(req)
  3274  	if err != nil {
  3275  		result.Response = autorest.Response{Response: resp}
  3276  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", resp, "Failure sending request")
  3277  		return
  3278  	}
  3279  
  3280  	result, err = client.UpdateTagResponder(resp)
  3281  	if err != nil {
  3282  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", resp, "Failure responding to request")
  3283  		return
  3284  	}
  3285  
  3286  	return
  3287  }
  3288  
  3289  // UpdateTagPreparer prepares the UpdateTag request.
  3290  func (client BaseClient) UpdateTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, updatedTag Tag) (*http.Request, error) {
  3291  	urlParameters := map[string]interface{}{
  3292  		"Endpoint": client.Endpoint,
  3293  	}
  3294  
  3295  	pathParameters := map[string]interface{}{
  3296  		"projectId": autorest.Encode("path", projectID),
  3297  		"tagId":     autorest.Encode("path", tagID),
  3298  	}
  3299  
  3300  	updatedTag.ID = nil
  3301  	updatedTag.ImageCount = nil
  3302  	preparer := autorest.CreatePreparer(
  3303  		autorest.AsContentType("application/json; charset=utf-8"),
  3304  		autorest.AsPatch(),
  3305  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v2.2/Training", urlParameters),
  3306  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  3307  		autorest.WithJSON(updatedTag),
  3308  		autorest.WithHeader("Training-Key", client.APIKey))
  3309  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3310  }
  3311  
  3312  // UpdateTagSender sends the UpdateTag request. The method will close the
  3313  // http.Response Body if it receives an error.
  3314  func (client BaseClient) UpdateTagSender(req *http.Request) (*http.Response, error) {
  3315  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3316  }
  3317  
  3318  // UpdateTagResponder handles the response to the UpdateTag request. The method always
  3319  // closes the http.Response Body.
  3320  func (client BaseClient) UpdateTagResponder(resp *http.Response) (result Tag, err error) {
  3321  	err = autorest.Respond(
  3322  		resp,
  3323  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3324  		autorest.ByUnmarshallingJSON(&result),
  3325  		autorest.ByClosing())
  3326  	result.Response = autorest.Response{Response: resp}
  3327  	return
  3328  }
  3329  

View as plain text