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

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

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

View as plain text