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

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

     1  // Package training implements the Azure ARM Training service API version 3.1.
     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.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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  // allImages - flag to specify delete all images, specify this flag or a list of images. Using this flag will
   786  // return a 202 response to indicate the images are being deleted.
   787  // allIterations - removes these images from all iterations, not just the current workspace. Using this flag
   788  // will return a 202 response to indicate the images are being deleted.
   789  func (client BaseClient) DeleteImages(ctx context.Context, projectID uuid.UUID, imageIds []uuid.UUID, allImages *bool, allIterations *bool) (result autorest.Response, err error) {
   790  	if tracing.IsEnabled() {
   791  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImages")
   792  		defer func() {
   793  			sc := -1
   794  			if result.Response != nil {
   795  				sc = result.Response.StatusCode
   796  			}
   797  			tracing.EndSpan(ctx, sc, err)
   798  		}()
   799  	}
   800  	if err := validation.Validate([]validation.Validation{
   801  		{TargetValue: imageIds,
   802  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: false,
   803  				Chain: []validation.Constraint{{Target: "imageIds", Name: validation.MaxItems, Rule: 256, Chain: nil},
   804  					{Target: "imageIds", Name: validation.MinItems, Rule: 0, Chain: nil},
   805  				}}}}}); err != nil {
   806  		return result, validation.NewError("training.BaseClient", "DeleteImages", err.Error())
   807  	}
   808  
   809  	req, err := client.DeleteImagesPreparer(ctx, projectID, imageIds, allImages, allIterations)
   810  	if err != nil {
   811  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", nil, "Failure preparing request")
   812  		return
   813  	}
   814  
   815  	resp, err := client.DeleteImagesSender(req)
   816  	if err != nil {
   817  		result.Response = resp
   818  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", resp, "Failure sending request")
   819  		return
   820  	}
   821  
   822  	result, err = client.DeleteImagesResponder(resp)
   823  	if err != nil {
   824  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", resp, "Failure responding to request")
   825  		return
   826  	}
   827  
   828  	return
   829  }
   830  
   831  // DeleteImagesPreparer prepares the DeleteImages request.
   832  func (client BaseClient) DeleteImagesPreparer(ctx context.Context, projectID uuid.UUID, imageIds []uuid.UUID, allImages *bool, allIterations *bool) (*http.Request, error) {
   833  	urlParameters := map[string]interface{}{
   834  		"Endpoint": client.Endpoint,
   835  	}
   836  
   837  	pathParameters := map[string]interface{}{
   838  		"projectId": autorest.Encode("path", projectID),
   839  	}
   840  
   841  	queryParameters := map[string]interface{}{}
   842  	if imageIds != nil && len(imageIds) > 0 {
   843  		queryParameters["imageIds"] = autorest.Encode("query", imageIds, ",")
   844  	}
   845  	if allImages != nil {
   846  		queryParameters["allImages"] = autorest.Encode("query", *allImages)
   847  	}
   848  	if allIterations != nil {
   849  		queryParameters["allIterations"] = autorest.Encode("query", *allIterations)
   850  	}
   851  
   852  	preparer := autorest.CreatePreparer(
   853  		autorest.AsDelete(),
   854  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
   855  		autorest.WithPathParameters("/projects/{projectId}/images", pathParameters),
   856  		autorest.WithQueryParameters(queryParameters),
   857  		autorest.WithHeader("Training-Key", client.APIKey))
   858  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   859  }
   860  
   861  // DeleteImagesSender sends the DeleteImages request. The method will close the
   862  // http.Response Body if it receives an error.
   863  func (client BaseClient) DeleteImagesSender(req *http.Request) (*http.Response, error) {
   864  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   865  }
   866  
   867  // DeleteImagesResponder handles the response to the DeleteImages request. The method always
   868  // closes the http.Response Body.
   869  func (client BaseClient) DeleteImagesResponder(resp *http.Response) (result autorest.Response, err error) {
   870  	err = autorest.Respond(
   871  		resp,
   872  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   873  		autorest.ByClosing())
   874  	result.Response = resp
   875  	return
   876  }
   877  
   878  // DeleteImageTags sends the delete image tags request.
   879  // Parameters:
   880  // projectID - the project id.
   881  // imageIds - image ids. Limited to 64 images.
   882  // tagIds - tags to be deleted from the specified images. Limited to 20 tags.
   883  func (client BaseClient) DeleteImageTags(ctx context.Context, projectID uuid.UUID, imageIds []uuid.UUID, tagIds []uuid.UUID) (result autorest.Response, err error) {
   884  	if tracing.IsEnabled() {
   885  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImageTags")
   886  		defer func() {
   887  			sc := -1
   888  			if result.Response != nil {
   889  				sc = result.Response.StatusCode
   890  			}
   891  			tracing.EndSpan(ctx, sc, err)
   892  		}()
   893  	}
   894  	if err := validation.Validate([]validation.Validation{
   895  		{TargetValue: imageIds,
   896  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: true,
   897  				Chain: []validation.Constraint{{Target: "imageIds", Name: validation.MaxItems, Rule: 64, Chain: nil},
   898  					{Target: "imageIds", Name: validation.MinItems, Rule: 0, Chain: nil},
   899  				}}}},
   900  		{TargetValue: tagIds,
   901  			Constraints: []validation.Constraint{{Target: "tagIds", Name: validation.Null, Rule: true,
   902  				Chain: []validation.Constraint{{Target: "tagIds", Name: validation.MaxItems, Rule: 20, Chain: nil},
   903  					{Target: "tagIds", Name: validation.MinItems, Rule: 0, Chain: nil},
   904  				}}}}}); err != nil {
   905  		return result, validation.NewError("training.BaseClient", "DeleteImageTags", err.Error())
   906  	}
   907  
   908  	req, err := client.DeleteImageTagsPreparer(ctx, projectID, imageIds, tagIds)
   909  	if err != nil {
   910  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", nil, "Failure preparing request")
   911  		return
   912  	}
   913  
   914  	resp, err := client.DeleteImageTagsSender(req)
   915  	if err != nil {
   916  		result.Response = resp
   917  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", resp, "Failure sending request")
   918  		return
   919  	}
   920  
   921  	result, err = client.DeleteImageTagsResponder(resp)
   922  	if err != nil {
   923  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", resp, "Failure responding to request")
   924  		return
   925  	}
   926  
   927  	return
   928  }
   929  
   930  // DeleteImageTagsPreparer prepares the DeleteImageTags request.
   931  func (client BaseClient) DeleteImageTagsPreparer(ctx context.Context, projectID uuid.UUID, imageIds []uuid.UUID, tagIds []uuid.UUID) (*http.Request, error) {
   932  	urlParameters := map[string]interface{}{
   933  		"Endpoint": client.Endpoint,
   934  	}
   935  
   936  	pathParameters := map[string]interface{}{
   937  		"projectId": autorest.Encode("path", projectID),
   938  	}
   939  
   940  	queryParameters := map[string]interface{}{
   941  		"imageIds": autorest.Encode("query", imageIds, ","),
   942  		"tagIds":   autorest.Encode("query", tagIds, ","),
   943  	}
   944  
   945  	preparer := autorest.CreatePreparer(
   946  		autorest.AsDelete(),
   947  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
   948  		autorest.WithPathParameters("/projects/{projectId}/images/tags", pathParameters),
   949  		autorest.WithQueryParameters(queryParameters),
   950  		autorest.WithHeader("Training-Key", client.APIKey))
   951  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   952  }
   953  
   954  // DeleteImageTagsSender sends the DeleteImageTags request. The method will close the
   955  // http.Response Body if it receives an error.
   956  func (client BaseClient) DeleteImageTagsSender(req *http.Request) (*http.Response, error) {
   957  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   958  }
   959  
   960  // DeleteImageTagsResponder handles the response to the DeleteImageTags request. The method always
   961  // closes the http.Response Body.
   962  func (client BaseClient) DeleteImageTagsResponder(resp *http.Response) (result autorest.Response, err error) {
   963  	err = autorest.Respond(
   964  		resp,
   965  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   966  		autorest.ByClosing())
   967  	result.Response = resp
   968  	return
   969  }
   970  
   971  // DeleteIteration sends the delete iteration request.
   972  // Parameters:
   973  // projectID - the project id.
   974  // iterationID - the iteration id.
   975  func (client BaseClient) DeleteIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result autorest.Response, err error) {
   976  	if tracing.IsEnabled() {
   977  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteIteration")
   978  		defer func() {
   979  			sc := -1
   980  			if result.Response != nil {
   981  				sc = result.Response.StatusCode
   982  			}
   983  			tracing.EndSpan(ctx, sc, err)
   984  		}()
   985  	}
   986  	req, err := client.DeleteIterationPreparer(ctx, projectID, iterationID)
   987  	if err != nil {
   988  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", nil, "Failure preparing request")
   989  		return
   990  	}
   991  
   992  	resp, err := client.DeleteIterationSender(req)
   993  	if err != nil {
   994  		result.Response = resp
   995  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", resp, "Failure sending request")
   996  		return
   997  	}
   998  
   999  	result, err = client.DeleteIterationResponder(resp)
  1000  	if err != nil {
  1001  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", resp, "Failure responding to request")
  1002  		return
  1003  	}
  1004  
  1005  	return
  1006  }
  1007  
  1008  // DeleteIterationPreparer prepares the DeleteIteration request.
  1009  func (client BaseClient) DeleteIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  1010  	urlParameters := map[string]interface{}{
  1011  		"Endpoint": client.Endpoint,
  1012  	}
  1013  
  1014  	pathParameters := map[string]interface{}{
  1015  		"iterationId": autorest.Encode("path", iterationID),
  1016  		"projectId":   autorest.Encode("path", projectID),
  1017  	}
  1018  
  1019  	preparer := autorest.CreatePreparer(
  1020  		autorest.AsDelete(),
  1021  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1022  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
  1023  		autorest.WithHeader("Training-Key", client.APIKey))
  1024  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1025  }
  1026  
  1027  // DeleteIterationSender sends the DeleteIteration request. The method will close the
  1028  // http.Response Body if it receives an error.
  1029  func (client BaseClient) DeleteIterationSender(req *http.Request) (*http.Response, error) {
  1030  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1031  }
  1032  
  1033  // DeleteIterationResponder handles the response to the DeleteIteration request. The method always
  1034  // closes the http.Response Body.
  1035  func (client BaseClient) DeleteIterationResponder(resp *http.Response) (result autorest.Response, err error) {
  1036  	err = autorest.Respond(
  1037  		resp,
  1038  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1039  		autorest.ByClosing())
  1040  	result.Response = resp
  1041  	return
  1042  }
  1043  
  1044  // DeletePrediction sends the delete prediction request.
  1045  // Parameters:
  1046  // projectID - the project id.
  1047  // ids - the prediction ids. Limited to 64.
  1048  func (client BaseClient) DeletePrediction(ctx context.Context, projectID uuid.UUID, ids []uuid.UUID) (result autorest.Response, err error) {
  1049  	if tracing.IsEnabled() {
  1050  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeletePrediction")
  1051  		defer func() {
  1052  			sc := -1
  1053  			if result.Response != nil {
  1054  				sc = result.Response.StatusCode
  1055  			}
  1056  			tracing.EndSpan(ctx, sc, err)
  1057  		}()
  1058  	}
  1059  	if err := validation.Validate([]validation.Validation{
  1060  		{TargetValue: ids,
  1061  			Constraints: []validation.Constraint{{Target: "ids", Name: validation.Null, Rule: true,
  1062  				Chain: []validation.Constraint{{Target: "ids", Name: validation.MaxItems, Rule: 64, Chain: nil},
  1063  					{Target: "ids", Name: validation.MinItems, Rule: 0, Chain: nil},
  1064  				}}}}}); err != nil {
  1065  		return result, validation.NewError("training.BaseClient", "DeletePrediction", err.Error())
  1066  	}
  1067  
  1068  	req, err := client.DeletePredictionPreparer(ctx, projectID, ids)
  1069  	if err != nil {
  1070  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", nil, "Failure preparing request")
  1071  		return
  1072  	}
  1073  
  1074  	resp, err := client.DeletePredictionSender(req)
  1075  	if err != nil {
  1076  		result.Response = resp
  1077  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", resp, "Failure sending request")
  1078  		return
  1079  	}
  1080  
  1081  	result, err = client.DeletePredictionResponder(resp)
  1082  	if err != nil {
  1083  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", resp, "Failure responding to request")
  1084  		return
  1085  	}
  1086  
  1087  	return
  1088  }
  1089  
  1090  // DeletePredictionPreparer prepares the DeletePrediction request.
  1091  func (client BaseClient) DeletePredictionPreparer(ctx context.Context, projectID uuid.UUID, ids []uuid.UUID) (*http.Request, error) {
  1092  	urlParameters := map[string]interface{}{
  1093  		"Endpoint": client.Endpoint,
  1094  	}
  1095  
  1096  	pathParameters := map[string]interface{}{
  1097  		"projectId": autorest.Encode("path", projectID),
  1098  	}
  1099  
  1100  	queryParameters := map[string]interface{}{
  1101  		"ids": autorest.Encode("query", ids, ","),
  1102  	}
  1103  
  1104  	preparer := autorest.CreatePreparer(
  1105  		autorest.AsDelete(),
  1106  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1107  		autorest.WithPathParameters("/projects/{projectId}/predictions", pathParameters),
  1108  		autorest.WithQueryParameters(queryParameters),
  1109  		autorest.WithHeader("Training-Key", client.APIKey))
  1110  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1111  }
  1112  
  1113  // DeletePredictionSender sends the DeletePrediction request. The method will close the
  1114  // http.Response Body if it receives an error.
  1115  func (client BaseClient) DeletePredictionSender(req *http.Request) (*http.Response, error) {
  1116  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1117  }
  1118  
  1119  // DeletePredictionResponder handles the response to the DeletePrediction request. The method always
  1120  // closes the http.Response Body.
  1121  func (client BaseClient) DeletePredictionResponder(resp *http.Response) (result autorest.Response, err error) {
  1122  	err = autorest.Respond(
  1123  		resp,
  1124  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1125  		autorest.ByClosing())
  1126  	result.Response = resp
  1127  	return
  1128  }
  1129  
  1130  // DeleteProject sends the delete project request.
  1131  // Parameters:
  1132  // projectID - the project id.
  1133  func (client BaseClient) DeleteProject(ctx context.Context, projectID uuid.UUID) (result autorest.Response, err error) {
  1134  	if tracing.IsEnabled() {
  1135  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteProject")
  1136  		defer func() {
  1137  			sc := -1
  1138  			if result.Response != nil {
  1139  				sc = result.Response.StatusCode
  1140  			}
  1141  			tracing.EndSpan(ctx, sc, err)
  1142  		}()
  1143  	}
  1144  	req, err := client.DeleteProjectPreparer(ctx, projectID)
  1145  	if err != nil {
  1146  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", nil, "Failure preparing request")
  1147  		return
  1148  	}
  1149  
  1150  	resp, err := client.DeleteProjectSender(req)
  1151  	if err != nil {
  1152  		result.Response = resp
  1153  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", resp, "Failure sending request")
  1154  		return
  1155  	}
  1156  
  1157  	result, err = client.DeleteProjectResponder(resp)
  1158  	if err != nil {
  1159  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", resp, "Failure responding to request")
  1160  		return
  1161  	}
  1162  
  1163  	return
  1164  }
  1165  
  1166  // DeleteProjectPreparer prepares the DeleteProject request.
  1167  func (client BaseClient) DeleteProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  1168  	urlParameters := map[string]interface{}{
  1169  		"Endpoint": client.Endpoint,
  1170  	}
  1171  
  1172  	pathParameters := map[string]interface{}{
  1173  		"projectId": autorest.Encode("path", projectID),
  1174  	}
  1175  
  1176  	preparer := autorest.CreatePreparer(
  1177  		autorest.AsDelete(),
  1178  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1179  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  1180  		autorest.WithHeader("Training-Key", client.APIKey))
  1181  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1182  }
  1183  
  1184  // DeleteProjectSender sends the DeleteProject request. The method will close the
  1185  // http.Response Body if it receives an error.
  1186  func (client BaseClient) DeleteProjectSender(req *http.Request) (*http.Response, error) {
  1187  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1188  }
  1189  
  1190  // DeleteProjectResponder handles the response to the DeleteProject request. The method always
  1191  // closes the http.Response Body.
  1192  func (client BaseClient) DeleteProjectResponder(resp *http.Response) (result autorest.Response, err error) {
  1193  	err = autorest.Respond(
  1194  		resp,
  1195  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1196  		autorest.ByClosing())
  1197  	result.Response = resp
  1198  	return
  1199  }
  1200  
  1201  // DeleteTag sends the delete tag request.
  1202  // Parameters:
  1203  // projectID - the project id.
  1204  // tagID - id of the tag to be deleted.
  1205  func (client BaseClient) DeleteTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID) (result autorest.Response, err error) {
  1206  	if tracing.IsEnabled() {
  1207  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteTag")
  1208  		defer func() {
  1209  			sc := -1
  1210  			if result.Response != nil {
  1211  				sc = result.Response.StatusCode
  1212  			}
  1213  			tracing.EndSpan(ctx, sc, err)
  1214  		}()
  1215  	}
  1216  	req, err := client.DeleteTagPreparer(ctx, projectID, tagID)
  1217  	if err != nil {
  1218  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", nil, "Failure preparing request")
  1219  		return
  1220  	}
  1221  
  1222  	resp, err := client.DeleteTagSender(req)
  1223  	if err != nil {
  1224  		result.Response = resp
  1225  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", resp, "Failure sending request")
  1226  		return
  1227  	}
  1228  
  1229  	result, err = client.DeleteTagResponder(resp)
  1230  	if err != nil {
  1231  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", resp, "Failure responding to request")
  1232  		return
  1233  	}
  1234  
  1235  	return
  1236  }
  1237  
  1238  // DeleteTagPreparer prepares the DeleteTag request.
  1239  func (client BaseClient) DeleteTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID) (*http.Request, error) {
  1240  	urlParameters := map[string]interface{}{
  1241  		"Endpoint": client.Endpoint,
  1242  	}
  1243  
  1244  	pathParameters := map[string]interface{}{
  1245  		"projectId": autorest.Encode("path", projectID),
  1246  		"tagId":     autorest.Encode("path", tagID),
  1247  	}
  1248  
  1249  	preparer := autorest.CreatePreparer(
  1250  		autorest.AsDelete(),
  1251  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1252  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  1253  		autorest.WithHeader("Training-Key", client.APIKey))
  1254  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1255  }
  1256  
  1257  // DeleteTagSender sends the DeleteTag request. The method will close the
  1258  // http.Response Body if it receives an error.
  1259  func (client BaseClient) DeleteTagSender(req *http.Request) (*http.Response, error) {
  1260  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1261  }
  1262  
  1263  // DeleteTagResponder handles the response to the DeleteTag request. The method always
  1264  // closes the http.Response Body.
  1265  func (client BaseClient) DeleteTagResponder(resp *http.Response) (result autorest.Response, err error) {
  1266  	err = autorest.Respond(
  1267  		resp,
  1268  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1269  		autorest.ByClosing())
  1270  	result.Response = resp
  1271  	return
  1272  }
  1273  
  1274  // ExportIteration sends the export iteration request.
  1275  // Parameters:
  1276  // projectID - the project id.
  1277  // iterationID - the iteration id.
  1278  // platform - the target platform.
  1279  // flavor - the flavor of the target platform.
  1280  func (client BaseClient) ExportIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, platform string, flavor string) (result Export, err error) {
  1281  	if tracing.IsEnabled() {
  1282  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.ExportIteration")
  1283  		defer func() {
  1284  			sc := -1
  1285  			if result.Response.Response != nil {
  1286  				sc = result.Response.Response.StatusCode
  1287  			}
  1288  			tracing.EndSpan(ctx, sc, err)
  1289  		}()
  1290  	}
  1291  	req, err := client.ExportIterationPreparer(ctx, projectID, iterationID, platform, flavor)
  1292  	if err != nil {
  1293  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", nil, "Failure preparing request")
  1294  		return
  1295  	}
  1296  
  1297  	resp, err := client.ExportIterationSender(req)
  1298  	if err != nil {
  1299  		result.Response = autorest.Response{Response: resp}
  1300  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", resp, "Failure sending request")
  1301  		return
  1302  	}
  1303  
  1304  	result, err = client.ExportIterationResponder(resp)
  1305  	if err != nil {
  1306  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", resp, "Failure responding to request")
  1307  		return
  1308  	}
  1309  
  1310  	return
  1311  }
  1312  
  1313  // ExportIterationPreparer prepares the ExportIteration request.
  1314  func (client BaseClient) ExportIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, platform string, flavor string) (*http.Request, error) {
  1315  	urlParameters := map[string]interface{}{
  1316  		"Endpoint": client.Endpoint,
  1317  	}
  1318  
  1319  	pathParameters := map[string]interface{}{
  1320  		"iterationId": autorest.Encode("path", iterationID),
  1321  		"projectId":   autorest.Encode("path", projectID),
  1322  	}
  1323  
  1324  	queryParameters := map[string]interface{}{
  1325  		"platform": autorest.Encode("query", platform),
  1326  	}
  1327  	if len(string(flavor)) > 0 {
  1328  		queryParameters["flavor"] = autorest.Encode("query", flavor)
  1329  	}
  1330  
  1331  	preparer := autorest.CreatePreparer(
  1332  		autorest.AsPost(),
  1333  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1334  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/export", pathParameters),
  1335  		autorest.WithQueryParameters(queryParameters),
  1336  		autorest.WithHeader("Training-Key", client.APIKey))
  1337  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1338  }
  1339  
  1340  // ExportIterationSender sends the ExportIteration request. The method will close the
  1341  // http.Response Body if it receives an error.
  1342  func (client BaseClient) ExportIterationSender(req *http.Request) (*http.Response, error) {
  1343  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1344  }
  1345  
  1346  // ExportIterationResponder handles the response to the ExportIteration request. The method always
  1347  // closes the http.Response Body.
  1348  func (client BaseClient) ExportIterationResponder(resp *http.Response) (result Export, err error) {
  1349  	err = autorest.Respond(
  1350  		resp,
  1351  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1352  		autorest.ByUnmarshallingJSON(&result),
  1353  		autorest.ByClosing())
  1354  	result.Response = autorest.Response{Response: resp}
  1355  	return
  1356  }
  1357  
  1358  // GetDomain sends the get domain request.
  1359  // Parameters:
  1360  // domainID - the id of the domain to get information about.
  1361  func (client BaseClient) GetDomain(ctx context.Context, domainID uuid.UUID) (result Domain, err error) {
  1362  	if tracing.IsEnabled() {
  1363  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetDomain")
  1364  		defer func() {
  1365  			sc := -1
  1366  			if result.Response.Response != nil {
  1367  				sc = result.Response.Response.StatusCode
  1368  			}
  1369  			tracing.EndSpan(ctx, sc, err)
  1370  		}()
  1371  	}
  1372  	req, err := client.GetDomainPreparer(ctx, domainID)
  1373  	if err != nil {
  1374  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", nil, "Failure preparing request")
  1375  		return
  1376  	}
  1377  
  1378  	resp, err := client.GetDomainSender(req)
  1379  	if err != nil {
  1380  		result.Response = autorest.Response{Response: resp}
  1381  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", resp, "Failure sending request")
  1382  		return
  1383  	}
  1384  
  1385  	result, err = client.GetDomainResponder(resp)
  1386  	if err != nil {
  1387  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", resp, "Failure responding to request")
  1388  		return
  1389  	}
  1390  
  1391  	return
  1392  }
  1393  
  1394  // GetDomainPreparer prepares the GetDomain request.
  1395  func (client BaseClient) GetDomainPreparer(ctx context.Context, domainID uuid.UUID) (*http.Request, error) {
  1396  	urlParameters := map[string]interface{}{
  1397  		"Endpoint": client.Endpoint,
  1398  	}
  1399  
  1400  	pathParameters := map[string]interface{}{
  1401  		"domainId": autorest.Encode("path", domainID),
  1402  	}
  1403  
  1404  	preparer := autorest.CreatePreparer(
  1405  		autorest.AsGet(),
  1406  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1407  		autorest.WithPathParameters("/domains/{domainId}", pathParameters),
  1408  		autorest.WithHeader("Training-Key", client.APIKey))
  1409  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1410  }
  1411  
  1412  // GetDomainSender sends the GetDomain request. The method will close the
  1413  // http.Response Body if it receives an error.
  1414  func (client BaseClient) GetDomainSender(req *http.Request) (*http.Response, error) {
  1415  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1416  }
  1417  
  1418  // GetDomainResponder handles the response to the GetDomain request. The method always
  1419  // closes the http.Response Body.
  1420  func (client BaseClient) GetDomainResponder(resp *http.Response) (result Domain, err error) {
  1421  	err = autorest.Respond(
  1422  		resp,
  1423  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1424  		autorest.ByUnmarshallingJSON(&result),
  1425  		autorest.ByClosing())
  1426  	result.Response = autorest.Response{Response: resp}
  1427  	return
  1428  }
  1429  
  1430  // GetDomains sends the get domains request.
  1431  func (client BaseClient) GetDomains(ctx context.Context) (result ListDomain, err error) {
  1432  	if tracing.IsEnabled() {
  1433  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetDomains")
  1434  		defer func() {
  1435  			sc := -1
  1436  			if result.Response.Response != nil {
  1437  				sc = result.Response.Response.StatusCode
  1438  			}
  1439  			tracing.EndSpan(ctx, sc, err)
  1440  		}()
  1441  	}
  1442  	req, err := client.GetDomainsPreparer(ctx)
  1443  	if err != nil {
  1444  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", nil, "Failure preparing request")
  1445  		return
  1446  	}
  1447  
  1448  	resp, err := client.GetDomainsSender(req)
  1449  	if err != nil {
  1450  		result.Response = autorest.Response{Response: resp}
  1451  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", resp, "Failure sending request")
  1452  		return
  1453  	}
  1454  
  1455  	result, err = client.GetDomainsResponder(resp)
  1456  	if err != nil {
  1457  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", resp, "Failure responding to request")
  1458  		return
  1459  	}
  1460  
  1461  	return
  1462  }
  1463  
  1464  // GetDomainsPreparer prepares the GetDomains request.
  1465  func (client BaseClient) GetDomainsPreparer(ctx context.Context) (*http.Request, error) {
  1466  	urlParameters := map[string]interface{}{
  1467  		"Endpoint": client.Endpoint,
  1468  	}
  1469  
  1470  	preparer := autorest.CreatePreparer(
  1471  		autorest.AsGet(),
  1472  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1473  		autorest.WithPath("/domains"),
  1474  		autorest.WithHeader("Training-Key", client.APIKey))
  1475  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1476  }
  1477  
  1478  // GetDomainsSender sends the GetDomains request. The method will close the
  1479  // http.Response Body if it receives an error.
  1480  func (client BaseClient) GetDomainsSender(req *http.Request) (*http.Response, error) {
  1481  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1482  }
  1483  
  1484  // GetDomainsResponder handles the response to the GetDomains request. The method always
  1485  // closes the http.Response Body.
  1486  func (client BaseClient) GetDomainsResponder(resp *http.Response) (result ListDomain, err error) {
  1487  	err = autorest.Respond(
  1488  		resp,
  1489  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1490  		autorest.ByUnmarshallingJSON(&result.Value),
  1491  		autorest.ByClosing())
  1492  	result.Response = autorest.Response{Response: resp}
  1493  	return
  1494  }
  1495  
  1496  // GetExports sends the get exports request.
  1497  // Parameters:
  1498  // projectID - the project id.
  1499  // iterationID - the iteration id.
  1500  func (client BaseClient) GetExports(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result ListExport, err error) {
  1501  	if tracing.IsEnabled() {
  1502  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetExports")
  1503  		defer func() {
  1504  			sc := -1
  1505  			if result.Response.Response != nil {
  1506  				sc = result.Response.Response.StatusCode
  1507  			}
  1508  			tracing.EndSpan(ctx, sc, err)
  1509  		}()
  1510  	}
  1511  	req, err := client.GetExportsPreparer(ctx, projectID, iterationID)
  1512  	if err != nil {
  1513  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", nil, "Failure preparing request")
  1514  		return
  1515  	}
  1516  
  1517  	resp, err := client.GetExportsSender(req)
  1518  	if err != nil {
  1519  		result.Response = autorest.Response{Response: resp}
  1520  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", resp, "Failure sending request")
  1521  		return
  1522  	}
  1523  
  1524  	result, err = client.GetExportsResponder(resp)
  1525  	if err != nil {
  1526  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", resp, "Failure responding to request")
  1527  		return
  1528  	}
  1529  
  1530  	return
  1531  }
  1532  
  1533  // GetExportsPreparer prepares the GetExports request.
  1534  func (client BaseClient) GetExportsPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  1535  	urlParameters := map[string]interface{}{
  1536  		"Endpoint": client.Endpoint,
  1537  	}
  1538  
  1539  	pathParameters := map[string]interface{}{
  1540  		"iterationId": autorest.Encode("path", iterationID),
  1541  		"projectId":   autorest.Encode("path", projectID),
  1542  	}
  1543  
  1544  	preparer := autorest.CreatePreparer(
  1545  		autorest.AsGet(),
  1546  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1547  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/export", pathParameters),
  1548  		autorest.WithHeader("Training-Key", client.APIKey))
  1549  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1550  }
  1551  
  1552  // GetExportsSender sends the GetExports request. The method will close the
  1553  // http.Response Body if it receives an error.
  1554  func (client BaseClient) GetExportsSender(req *http.Request) (*http.Response, error) {
  1555  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1556  }
  1557  
  1558  // GetExportsResponder handles the response to the GetExports request. The method always
  1559  // closes the http.Response Body.
  1560  func (client BaseClient) GetExportsResponder(resp *http.Response) (result ListExport, err error) {
  1561  	err = autorest.Respond(
  1562  		resp,
  1563  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1564  		autorest.ByUnmarshallingJSON(&result.Value),
  1565  		autorest.ByClosing())
  1566  	result.Response = autorest.Response{Response: resp}
  1567  	return
  1568  }
  1569  
  1570  // GetImagePerformanceCount the filtering is on an and/or relationship. For example, if the provided tag ids are for
  1571  // the "Dog" and
  1572  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  1573  // Parameters:
  1574  // projectID - the project id.
  1575  // iterationID - the iteration id. Defaults to workspace.
  1576  // tagIds - a list of tags ids to filter the images to count. Defaults to all tags when null.
  1577  func (client BaseClient) GetImagePerformanceCount(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []uuid.UUID) (result Int32, err error) {
  1578  	if tracing.IsEnabled() {
  1579  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagePerformanceCount")
  1580  		defer func() {
  1581  			sc := -1
  1582  			if result.Response.Response != nil {
  1583  				sc = result.Response.Response.StatusCode
  1584  			}
  1585  			tracing.EndSpan(ctx, sc, err)
  1586  		}()
  1587  	}
  1588  	req, err := client.GetImagePerformanceCountPreparer(ctx, projectID, iterationID, tagIds)
  1589  	if err != nil {
  1590  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", nil, "Failure preparing request")
  1591  		return
  1592  	}
  1593  
  1594  	resp, err := client.GetImagePerformanceCountSender(req)
  1595  	if err != nil {
  1596  		result.Response = autorest.Response{Response: resp}
  1597  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", resp, "Failure sending request")
  1598  		return
  1599  	}
  1600  
  1601  	result, err = client.GetImagePerformanceCountResponder(resp)
  1602  	if err != nil {
  1603  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", resp, "Failure responding to request")
  1604  		return
  1605  	}
  1606  
  1607  	return
  1608  }
  1609  
  1610  // GetImagePerformanceCountPreparer prepares the GetImagePerformanceCount request.
  1611  func (client BaseClient) GetImagePerformanceCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []uuid.UUID) (*http.Request, error) {
  1612  	urlParameters := map[string]interface{}{
  1613  		"Endpoint": client.Endpoint,
  1614  	}
  1615  
  1616  	pathParameters := map[string]interface{}{
  1617  		"iterationId": autorest.Encode("path", iterationID),
  1618  		"projectId":   autorest.Encode("path", projectID),
  1619  	}
  1620  
  1621  	queryParameters := map[string]interface{}{}
  1622  	if tagIds != nil && len(tagIds) > 0 {
  1623  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  1624  	}
  1625  
  1626  	preparer := autorest.CreatePreparer(
  1627  		autorest.AsGet(),
  1628  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1629  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance/images/count", pathParameters),
  1630  		autorest.WithQueryParameters(queryParameters),
  1631  		autorest.WithHeader("Training-Key", client.APIKey))
  1632  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1633  }
  1634  
  1635  // GetImagePerformanceCountSender sends the GetImagePerformanceCount request. The method will close the
  1636  // http.Response Body if it receives an error.
  1637  func (client BaseClient) GetImagePerformanceCountSender(req *http.Request) (*http.Response, error) {
  1638  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1639  }
  1640  
  1641  // GetImagePerformanceCountResponder handles the response to the GetImagePerformanceCount request. The method always
  1642  // closes the http.Response Body.
  1643  func (client BaseClient) GetImagePerformanceCountResponder(resp *http.Response) (result Int32, err error) {
  1644  	err = autorest.Respond(
  1645  		resp,
  1646  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1647  		autorest.ByUnmarshallingJSON(&result.Value),
  1648  		autorest.ByClosing())
  1649  	result.Response = autorest.Response{Response: resp}
  1650  	return
  1651  }
  1652  
  1653  // GetImagePerformances this API supports batching and range selection. By default it will only return first 50 images
  1654  // matching images.
  1655  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  1656  // The filtering is on an and/or relationship. For example, if the provided tag ids are for the "Dog" and
  1657  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  1658  // Parameters:
  1659  // projectID - the project id.
  1660  // iterationID - the iteration id. Defaults to workspace.
  1661  // tagIds - a list of tags ids to filter the images. Defaults to all tagged images when null. Limited to 20.
  1662  // orderBy - the ordering. Defaults to newest.
  1663  // take - maximum number of images to return. Defaults to 50, limited to 256.
  1664  // skip - number of images to skip before beginning the image batch. Defaults to 0.
  1665  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) {
  1666  	if tracing.IsEnabled() {
  1667  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagePerformances")
  1668  		defer func() {
  1669  			sc := -1
  1670  			if result.Response.Response != nil {
  1671  				sc = result.Response.Response.StatusCode
  1672  			}
  1673  			tracing.EndSpan(ctx, sc, err)
  1674  		}()
  1675  	}
  1676  	if err := validation.Validate([]validation.Validation{
  1677  		{TargetValue: tagIds,
  1678  			Constraints: []validation.Constraint{{Target: "tagIds", Name: validation.Null, Rule: false,
  1679  				Chain: []validation.Constraint{{Target: "tagIds", Name: validation.MaxItems, Rule: 20, Chain: nil},
  1680  					{Target: "tagIds", Name: validation.MinItems, Rule: 0, Chain: nil},
  1681  				}}}},
  1682  		{TargetValue: take,
  1683  			Constraints: []validation.Constraint{{Target: "take", Name: validation.Null, Rule: false,
  1684  				Chain: []validation.Constraint{{Target: "take", Name: validation.InclusiveMaximum, Rule: int64(256), Chain: nil},
  1685  					{Target: "take", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil},
  1686  				}}}}}); err != nil {
  1687  		return result, validation.NewError("training.BaseClient", "GetImagePerformances", err.Error())
  1688  	}
  1689  
  1690  	req, err := client.GetImagePerformancesPreparer(ctx, projectID, iterationID, tagIds, orderBy, take, skip)
  1691  	if err != nil {
  1692  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", nil, "Failure preparing request")
  1693  		return
  1694  	}
  1695  
  1696  	resp, err := client.GetImagePerformancesSender(req)
  1697  	if err != nil {
  1698  		result.Response = autorest.Response{Response: resp}
  1699  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", resp, "Failure sending request")
  1700  		return
  1701  	}
  1702  
  1703  	result, err = client.GetImagePerformancesResponder(resp)
  1704  	if err != nil {
  1705  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", resp, "Failure responding to request")
  1706  		return
  1707  	}
  1708  
  1709  	return
  1710  }
  1711  
  1712  // GetImagePerformancesPreparer prepares the GetImagePerformances request.
  1713  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) {
  1714  	urlParameters := map[string]interface{}{
  1715  		"Endpoint": client.Endpoint,
  1716  	}
  1717  
  1718  	pathParameters := map[string]interface{}{
  1719  		"iterationId": autorest.Encode("path", iterationID),
  1720  		"projectId":   autorest.Encode("path", projectID),
  1721  	}
  1722  
  1723  	queryParameters := map[string]interface{}{}
  1724  	if tagIds != nil && len(tagIds) > 0 {
  1725  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  1726  	}
  1727  	if len(string(orderBy)) > 0 {
  1728  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  1729  	}
  1730  	if take != nil {
  1731  		queryParameters["take"] = autorest.Encode("query", *take)
  1732  	} else {
  1733  		queryParameters["take"] = autorest.Encode("query", 50)
  1734  	}
  1735  	if skip != nil {
  1736  		queryParameters["skip"] = autorest.Encode("query", *skip)
  1737  	} else {
  1738  		queryParameters["skip"] = autorest.Encode("query", 0)
  1739  	}
  1740  
  1741  	preparer := autorest.CreatePreparer(
  1742  		autorest.AsGet(),
  1743  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1744  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance/images", pathParameters),
  1745  		autorest.WithQueryParameters(queryParameters),
  1746  		autorest.WithHeader("Training-Key", client.APIKey))
  1747  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1748  }
  1749  
  1750  // GetImagePerformancesSender sends the GetImagePerformances request. The method will close the
  1751  // http.Response Body if it receives an error.
  1752  func (client BaseClient) GetImagePerformancesSender(req *http.Request) (*http.Response, error) {
  1753  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1754  }
  1755  
  1756  // GetImagePerformancesResponder handles the response to the GetImagePerformances request. The method always
  1757  // closes the http.Response Body.
  1758  func (client BaseClient) GetImagePerformancesResponder(resp *http.Response) (result ListImagePerformance, err error) {
  1759  	err = autorest.Respond(
  1760  		resp,
  1761  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1762  		autorest.ByUnmarshallingJSON(&result.Value),
  1763  		autorest.ByClosing())
  1764  	result.Response = autorest.Response{Response: resp}
  1765  	return
  1766  }
  1767  
  1768  // GetImageRegionProposals this API will get region proposals for an image along with confidences for the region. It
  1769  // returns an empty array if no proposals are found.
  1770  // Parameters:
  1771  // projectID - the project id.
  1772  // imageID - the image id.
  1773  func (client BaseClient) GetImageRegionProposals(ctx context.Context, projectID uuid.UUID, imageID uuid.UUID) (result ImageRegionProposal, err error) {
  1774  	if tracing.IsEnabled() {
  1775  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImageRegionProposals")
  1776  		defer func() {
  1777  			sc := -1
  1778  			if result.Response.Response != nil {
  1779  				sc = result.Response.Response.StatusCode
  1780  			}
  1781  			tracing.EndSpan(ctx, sc, err)
  1782  		}()
  1783  	}
  1784  	req, err := client.GetImageRegionProposalsPreparer(ctx, projectID, imageID)
  1785  	if err != nil {
  1786  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", nil, "Failure preparing request")
  1787  		return
  1788  	}
  1789  
  1790  	resp, err := client.GetImageRegionProposalsSender(req)
  1791  	if err != nil {
  1792  		result.Response = autorest.Response{Response: resp}
  1793  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", resp, "Failure sending request")
  1794  		return
  1795  	}
  1796  
  1797  	result, err = client.GetImageRegionProposalsResponder(resp)
  1798  	if err != nil {
  1799  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", resp, "Failure responding to request")
  1800  		return
  1801  	}
  1802  
  1803  	return
  1804  }
  1805  
  1806  // GetImageRegionProposalsPreparer prepares the GetImageRegionProposals request.
  1807  func (client BaseClient) GetImageRegionProposalsPreparer(ctx context.Context, projectID uuid.UUID, imageID uuid.UUID) (*http.Request, error) {
  1808  	urlParameters := map[string]interface{}{
  1809  		"Endpoint": client.Endpoint,
  1810  	}
  1811  
  1812  	pathParameters := map[string]interface{}{
  1813  		"imageId":   autorest.Encode("path", imageID),
  1814  		"projectId": autorest.Encode("path", projectID),
  1815  	}
  1816  
  1817  	preparer := autorest.CreatePreparer(
  1818  		autorest.AsPost(),
  1819  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1820  		autorest.WithPathParameters("/projects/{projectId}/images/{imageId}/regionproposals", pathParameters),
  1821  		autorest.WithHeader("Training-Key", client.APIKey))
  1822  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1823  }
  1824  
  1825  // GetImageRegionProposalsSender sends the GetImageRegionProposals request. The method will close the
  1826  // http.Response Body if it receives an error.
  1827  func (client BaseClient) GetImageRegionProposalsSender(req *http.Request) (*http.Response, error) {
  1828  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1829  }
  1830  
  1831  // GetImageRegionProposalsResponder handles the response to the GetImageRegionProposals request. The method always
  1832  // closes the http.Response Body.
  1833  func (client BaseClient) GetImageRegionProposalsResponder(resp *http.Response) (result ImageRegionProposal, err error) {
  1834  	err = autorest.Respond(
  1835  		resp,
  1836  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1837  		autorest.ByUnmarshallingJSON(&result),
  1838  		autorest.ByClosing())
  1839  	result.Response = autorest.Response{Response: resp}
  1840  	return
  1841  }
  1842  
  1843  // GetImagesByIds this API will return a set of Images for the specified tags and optionally iteration. If no iteration
  1844  // is specified the
  1845  // current workspace is used.
  1846  // Parameters:
  1847  // projectID - the project id.
  1848  // imageIds - the list of image ids to retrieve. Limited to 256.
  1849  // iterationID - the iteration id. Defaults to workspace.
  1850  func (client BaseClient) GetImagesByIds(ctx context.Context, projectID uuid.UUID, imageIds []uuid.UUID, iterationID *uuid.UUID) (result ListImage, err error) {
  1851  	if tracing.IsEnabled() {
  1852  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagesByIds")
  1853  		defer func() {
  1854  			sc := -1
  1855  			if result.Response.Response != nil {
  1856  				sc = result.Response.Response.StatusCode
  1857  			}
  1858  			tracing.EndSpan(ctx, sc, err)
  1859  		}()
  1860  	}
  1861  	if err := validation.Validate([]validation.Validation{
  1862  		{TargetValue: imageIds,
  1863  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: false,
  1864  				Chain: []validation.Constraint{{Target: "imageIds", Name: validation.MaxItems, Rule: 256, Chain: nil},
  1865  					{Target: "imageIds", Name: validation.MinItems, Rule: 0, Chain: nil},
  1866  				}}}}}); err != nil {
  1867  		return result, validation.NewError("training.BaseClient", "GetImagesByIds", err.Error())
  1868  	}
  1869  
  1870  	req, err := client.GetImagesByIdsPreparer(ctx, projectID, imageIds, iterationID)
  1871  	if err != nil {
  1872  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", nil, "Failure preparing request")
  1873  		return
  1874  	}
  1875  
  1876  	resp, err := client.GetImagesByIdsSender(req)
  1877  	if err != nil {
  1878  		result.Response = autorest.Response{Response: resp}
  1879  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", resp, "Failure sending request")
  1880  		return
  1881  	}
  1882  
  1883  	result, err = client.GetImagesByIdsResponder(resp)
  1884  	if err != nil {
  1885  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", resp, "Failure responding to request")
  1886  		return
  1887  	}
  1888  
  1889  	return
  1890  }
  1891  
  1892  // GetImagesByIdsPreparer prepares the GetImagesByIds request.
  1893  func (client BaseClient) GetImagesByIdsPreparer(ctx context.Context, projectID uuid.UUID, imageIds []uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  1894  	urlParameters := map[string]interface{}{
  1895  		"Endpoint": client.Endpoint,
  1896  	}
  1897  
  1898  	pathParameters := map[string]interface{}{
  1899  		"projectId": autorest.Encode("path", projectID),
  1900  	}
  1901  
  1902  	queryParameters := map[string]interface{}{}
  1903  	if imageIds != nil && len(imageIds) > 0 {
  1904  		queryParameters["imageIds"] = autorest.Encode("query", imageIds, ",")
  1905  	}
  1906  	if iterationID != nil {
  1907  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  1908  	}
  1909  
  1910  	preparer := autorest.CreatePreparer(
  1911  		autorest.AsGet(),
  1912  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1913  		autorest.WithPathParameters("/projects/{projectId}/images/id", pathParameters),
  1914  		autorest.WithQueryParameters(queryParameters),
  1915  		autorest.WithHeader("Training-Key", client.APIKey))
  1916  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1917  }
  1918  
  1919  // GetImagesByIdsSender sends the GetImagesByIds request. The method will close the
  1920  // http.Response Body if it receives an error.
  1921  func (client BaseClient) GetImagesByIdsSender(req *http.Request) (*http.Response, error) {
  1922  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1923  }
  1924  
  1925  // GetImagesByIdsResponder handles the response to the GetImagesByIds request. The method always
  1926  // closes the http.Response Body.
  1927  func (client BaseClient) GetImagesByIdsResponder(resp *http.Response) (result ListImage, err error) {
  1928  	err = autorest.Respond(
  1929  		resp,
  1930  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1931  		autorest.ByUnmarshallingJSON(&result.Value),
  1932  		autorest.ByClosing())
  1933  	result.Response = autorest.Response{Response: resp}
  1934  	return
  1935  }
  1936  
  1937  // GetIteration sends the get iteration request.
  1938  // Parameters:
  1939  // projectID - the id of the project the iteration belongs to.
  1940  // iterationID - the id of the iteration to get.
  1941  func (client BaseClient) GetIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result Iteration, err error) {
  1942  	if tracing.IsEnabled() {
  1943  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIteration")
  1944  		defer func() {
  1945  			sc := -1
  1946  			if result.Response.Response != nil {
  1947  				sc = result.Response.Response.StatusCode
  1948  			}
  1949  			tracing.EndSpan(ctx, sc, err)
  1950  		}()
  1951  	}
  1952  	req, err := client.GetIterationPreparer(ctx, projectID, iterationID)
  1953  	if err != nil {
  1954  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", nil, "Failure preparing request")
  1955  		return
  1956  	}
  1957  
  1958  	resp, err := client.GetIterationSender(req)
  1959  	if err != nil {
  1960  		result.Response = autorest.Response{Response: resp}
  1961  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", resp, "Failure sending request")
  1962  		return
  1963  	}
  1964  
  1965  	result, err = client.GetIterationResponder(resp)
  1966  	if err != nil {
  1967  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", resp, "Failure responding to request")
  1968  		return
  1969  	}
  1970  
  1971  	return
  1972  }
  1973  
  1974  // GetIterationPreparer prepares the GetIteration request.
  1975  func (client BaseClient) GetIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  1976  	urlParameters := map[string]interface{}{
  1977  		"Endpoint": client.Endpoint,
  1978  	}
  1979  
  1980  	pathParameters := map[string]interface{}{
  1981  		"iterationId": autorest.Encode("path", iterationID),
  1982  		"projectId":   autorest.Encode("path", projectID),
  1983  	}
  1984  
  1985  	preparer := autorest.CreatePreparer(
  1986  		autorest.AsGet(),
  1987  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  1988  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
  1989  		autorest.WithHeader("Training-Key", client.APIKey))
  1990  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1991  }
  1992  
  1993  // GetIterationSender sends the GetIteration request. The method will close the
  1994  // http.Response Body if it receives an error.
  1995  func (client BaseClient) GetIterationSender(req *http.Request) (*http.Response, error) {
  1996  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1997  }
  1998  
  1999  // GetIterationResponder handles the response to the GetIteration request. The method always
  2000  // closes the http.Response Body.
  2001  func (client BaseClient) GetIterationResponder(resp *http.Response) (result Iteration, err error) {
  2002  	err = autorest.Respond(
  2003  		resp,
  2004  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2005  		autorest.ByUnmarshallingJSON(&result),
  2006  		autorest.ByClosing())
  2007  	result.Response = autorest.Response{Response: resp}
  2008  	return
  2009  }
  2010  
  2011  // GetIterationPerformance sends the get iteration performance request.
  2012  // Parameters:
  2013  // projectID - the id of the project the iteration belongs to.
  2014  // iterationID - the id of the iteration to get.
  2015  // threshold - the threshold used to determine true predictions.
  2016  // overlapThreshold - if applicable, the bounding box overlap threshold used to determine true predictions.
  2017  func (client BaseClient) GetIterationPerformance(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, threshold *float64, overlapThreshold *float64) (result IterationPerformance, err error) {
  2018  	if tracing.IsEnabled() {
  2019  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIterationPerformance")
  2020  		defer func() {
  2021  			sc := -1
  2022  			if result.Response.Response != nil {
  2023  				sc = result.Response.Response.StatusCode
  2024  			}
  2025  			tracing.EndSpan(ctx, sc, err)
  2026  		}()
  2027  	}
  2028  	req, err := client.GetIterationPerformancePreparer(ctx, projectID, iterationID, threshold, overlapThreshold)
  2029  	if err != nil {
  2030  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", nil, "Failure preparing request")
  2031  		return
  2032  	}
  2033  
  2034  	resp, err := client.GetIterationPerformanceSender(req)
  2035  	if err != nil {
  2036  		result.Response = autorest.Response{Response: resp}
  2037  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", resp, "Failure sending request")
  2038  		return
  2039  	}
  2040  
  2041  	result, err = client.GetIterationPerformanceResponder(resp)
  2042  	if err != nil {
  2043  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", resp, "Failure responding to request")
  2044  		return
  2045  	}
  2046  
  2047  	return
  2048  }
  2049  
  2050  // GetIterationPerformancePreparer prepares the GetIterationPerformance request.
  2051  func (client BaseClient) GetIterationPerformancePreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, threshold *float64, overlapThreshold *float64) (*http.Request, error) {
  2052  	urlParameters := map[string]interface{}{
  2053  		"Endpoint": client.Endpoint,
  2054  	}
  2055  
  2056  	pathParameters := map[string]interface{}{
  2057  		"iterationId": autorest.Encode("path", iterationID),
  2058  		"projectId":   autorest.Encode("path", projectID),
  2059  	}
  2060  
  2061  	queryParameters := map[string]interface{}{}
  2062  	if threshold != nil {
  2063  		queryParameters["threshold"] = autorest.Encode("query", *threshold)
  2064  	}
  2065  	if overlapThreshold != nil {
  2066  		queryParameters["overlapThreshold"] = autorest.Encode("query", *overlapThreshold)
  2067  	}
  2068  
  2069  	preparer := autorest.CreatePreparer(
  2070  		autorest.AsGet(),
  2071  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2072  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance", pathParameters),
  2073  		autorest.WithQueryParameters(queryParameters),
  2074  		autorest.WithHeader("Training-Key", client.APIKey))
  2075  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2076  }
  2077  
  2078  // GetIterationPerformanceSender sends the GetIterationPerformance request. The method will close the
  2079  // http.Response Body if it receives an error.
  2080  func (client BaseClient) GetIterationPerformanceSender(req *http.Request) (*http.Response, error) {
  2081  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2082  }
  2083  
  2084  // GetIterationPerformanceResponder handles the response to the GetIterationPerformance request. The method always
  2085  // closes the http.Response Body.
  2086  func (client BaseClient) GetIterationPerformanceResponder(resp *http.Response) (result IterationPerformance, err error) {
  2087  	err = autorest.Respond(
  2088  		resp,
  2089  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2090  		autorest.ByUnmarshallingJSON(&result),
  2091  		autorest.ByClosing())
  2092  	result.Response = autorest.Response{Response: resp}
  2093  	return
  2094  }
  2095  
  2096  // GetIterations sends the get iterations request.
  2097  // Parameters:
  2098  // projectID - the project id.
  2099  func (client BaseClient) GetIterations(ctx context.Context, projectID uuid.UUID) (result ListIteration, err error) {
  2100  	if tracing.IsEnabled() {
  2101  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIterations")
  2102  		defer func() {
  2103  			sc := -1
  2104  			if result.Response.Response != nil {
  2105  				sc = result.Response.Response.StatusCode
  2106  			}
  2107  			tracing.EndSpan(ctx, sc, err)
  2108  		}()
  2109  	}
  2110  	req, err := client.GetIterationsPreparer(ctx, projectID)
  2111  	if err != nil {
  2112  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", nil, "Failure preparing request")
  2113  		return
  2114  	}
  2115  
  2116  	resp, err := client.GetIterationsSender(req)
  2117  	if err != nil {
  2118  		result.Response = autorest.Response{Response: resp}
  2119  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", resp, "Failure sending request")
  2120  		return
  2121  	}
  2122  
  2123  	result, err = client.GetIterationsResponder(resp)
  2124  	if err != nil {
  2125  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", resp, "Failure responding to request")
  2126  		return
  2127  	}
  2128  
  2129  	return
  2130  }
  2131  
  2132  // GetIterationsPreparer prepares the GetIterations request.
  2133  func (client BaseClient) GetIterationsPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  2134  	urlParameters := map[string]interface{}{
  2135  		"Endpoint": client.Endpoint,
  2136  	}
  2137  
  2138  	pathParameters := map[string]interface{}{
  2139  		"projectId": autorest.Encode("path", projectID),
  2140  	}
  2141  
  2142  	preparer := autorest.CreatePreparer(
  2143  		autorest.AsGet(),
  2144  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2145  		autorest.WithPathParameters("/projects/{projectId}/iterations", pathParameters),
  2146  		autorest.WithHeader("Training-Key", client.APIKey))
  2147  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2148  }
  2149  
  2150  // GetIterationsSender sends the GetIterations request. The method will close the
  2151  // http.Response Body if it receives an error.
  2152  func (client BaseClient) GetIterationsSender(req *http.Request) (*http.Response, error) {
  2153  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2154  }
  2155  
  2156  // GetIterationsResponder handles the response to the GetIterations request. The method always
  2157  // closes the http.Response Body.
  2158  func (client BaseClient) GetIterationsResponder(resp *http.Response) (result ListIteration, err error) {
  2159  	err = autorest.Respond(
  2160  		resp,
  2161  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2162  		autorest.ByUnmarshallingJSON(&result.Value),
  2163  		autorest.ByClosing())
  2164  	result.Response = autorest.Response{Response: resp}
  2165  	return
  2166  }
  2167  
  2168  // GetProject sends the get project request.
  2169  // Parameters:
  2170  // projectID - the id of the project to get.
  2171  func (client BaseClient) GetProject(ctx context.Context, projectID uuid.UUID) (result Project, err error) {
  2172  	if tracing.IsEnabled() {
  2173  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetProject")
  2174  		defer func() {
  2175  			sc := -1
  2176  			if result.Response.Response != nil {
  2177  				sc = result.Response.Response.StatusCode
  2178  			}
  2179  			tracing.EndSpan(ctx, sc, err)
  2180  		}()
  2181  	}
  2182  	req, err := client.GetProjectPreparer(ctx, projectID)
  2183  	if err != nil {
  2184  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", nil, "Failure preparing request")
  2185  		return
  2186  	}
  2187  
  2188  	resp, err := client.GetProjectSender(req)
  2189  	if err != nil {
  2190  		result.Response = autorest.Response{Response: resp}
  2191  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", resp, "Failure sending request")
  2192  		return
  2193  	}
  2194  
  2195  	result, err = client.GetProjectResponder(resp)
  2196  	if err != nil {
  2197  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", resp, "Failure responding to request")
  2198  		return
  2199  	}
  2200  
  2201  	return
  2202  }
  2203  
  2204  // GetProjectPreparer prepares the GetProject request.
  2205  func (client BaseClient) GetProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  2206  	urlParameters := map[string]interface{}{
  2207  		"Endpoint": client.Endpoint,
  2208  	}
  2209  
  2210  	pathParameters := map[string]interface{}{
  2211  		"projectId": autorest.Encode("path", projectID),
  2212  	}
  2213  
  2214  	preparer := autorest.CreatePreparer(
  2215  		autorest.AsGet(),
  2216  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2217  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  2218  		autorest.WithHeader("Training-Key", client.APIKey))
  2219  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2220  }
  2221  
  2222  // GetProjectSender sends the GetProject request. The method will close the
  2223  // http.Response Body if it receives an error.
  2224  func (client BaseClient) GetProjectSender(req *http.Request) (*http.Response, error) {
  2225  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2226  }
  2227  
  2228  // GetProjectResponder handles the response to the GetProject request. The method always
  2229  // closes the http.Response Body.
  2230  func (client BaseClient) GetProjectResponder(resp *http.Response) (result Project, err error) {
  2231  	err = autorest.Respond(
  2232  		resp,
  2233  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2234  		autorest.ByUnmarshallingJSON(&result),
  2235  		autorest.ByClosing())
  2236  	result.Response = autorest.Response{Response: resp}
  2237  	return
  2238  }
  2239  
  2240  // GetProjects sends the get projects request.
  2241  func (client BaseClient) GetProjects(ctx context.Context) (result ListProject, err error) {
  2242  	if tracing.IsEnabled() {
  2243  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetProjects")
  2244  		defer func() {
  2245  			sc := -1
  2246  			if result.Response.Response != nil {
  2247  				sc = result.Response.Response.StatusCode
  2248  			}
  2249  			tracing.EndSpan(ctx, sc, err)
  2250  		}()
  2251  	}
  2252  	req, err := client.GetProjectsPreparer(ctx)
  2253  	if err != nil {
  2254  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", nil, "Failure preparing request")
  2255  		return
  2256  	}
  2257  
  2258  	resp, err := client.GetProjectsSender(req)
  2259  	if err != nil {
  2260  		result.Response = autorest.Response{Response: resp}
  2261  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", resp, "Failure sending request")
  2262  		return
  2263  	}
  2264  
  2265  	result, err = client.GetProjectsResponder(resp)
  2266  	if err != nil {
  2267  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", resp, "Failure responding to request")
  2268  		return
  2269  	}
  2270  
  2271  	return
  2272  }
  2273  
  2274  // GetProjectsPreparer prepares the GetProjects request.
  2275  func (client BaseClient) GetProjectsPreparer(ctx context.Context) (*http.Request, error) {
  2276  	urlParameters := map[string]interface{}{
  2277  		"Endpoint": client.Endpoint,
  2278  	}
  2279  
  2280  	preparer := autorest.CreatePreparer(
  2281  		autorest.AsGet(),
  2282  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2283  		autorest.WithPath("/projects"),
  2284  		autorest.WithHeader("Training-Key", client.APIKey))
  2285  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2286  }
  2287  
  2288  // GetProjectsSender sends the GetProjects request. The method will close the
  2289  // http.Response Body if it receives an error.
  2290  func (client BaseClient) GetProjectsSender(req *http.Request) (*http.Response, error) {
  2291  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2292  }
  2293  
  2294  // GetProjectsResponder handles the response to the GetProjects request. The method always
  2295  // closes the http.Response Body.
  2296  func (client BaseClient) GetProjectsResponder(resp *http.Response) (result ListProject, err error) {
  2297  	err = autorest.Respond(
  2298  		resp,
  2299  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2300  		autorest.ByUnmarshallingJSON(&result.Value),
  2301  		autorest.ByClosing())
  2302  	result.Response = autorest.Response{Response: resp}
  2303  	return
  2304  }
  2305  
  2306  // GetTag sends the get tag request.
  2307  // Parameters:
  2308  // projectID - the project this tag belongs to.
  2309  // tagID - the tag id.
  2310  // iterationID - the iteration to retrieve this tag from. Optional, defaults to current training set.
  2311  func (client BaseClient) GetTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, iterationID *uuid.UUID) (result Tag, err error) {
  2312  	if tracing.IsEnabled() {
  2313  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTag")
  2314  		defer func() {
  2315  			sc := -1
  2316  			if result.Response.Response != nil {
  2317  				sc = result.Response.Response.StatusCode
  2318  			}
  2319  			tracing.EndSpan(ctx, sc, err)
  2320  		}()
  2321  	}
  2322  	req, err := client.GetTagPreparer(ctx, projectID, tagID, iterationID)
  2323  	if err != nil {
  2324  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", nil, "Failure preparing request")
  2325  		return
  2326  	}
  2327  
  2328  	resp, err := client.GetTagSender(req)
  2329  	if err != nil {
  2330  		result.Response = autorest.Response{Response: resp}
  2331  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", resp, "Failure sending request")
  2332  		return
  2333  	}
  2334  
  2335  	result, err = client.GetTagResponder(resp)
  2336  	if err != nil {
  2337  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", resp, "Failure responding to request")
  2338  		return
  2339  	}
  2340  
  2341  	return
  2342  }
  2343  
  2344  // GetTagPreparer prepares the GetTag request.
  2345  func (client BaseClient) GetTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2346  	urlParameters := map[string]interface{}{
  2347  		"Endpoint": client.Endpoint,
  2348  	}
  2349  
  2350  	pathParameters := map[string]interface{}{
  2351  		"projectId": autorest.Encode("path", projectID),
  2352  		"tagId":     autorest.Encode("path", tagID),
  2353  	}
  2354  
  2355  	queryParameters := map[string]interface{}{}
  2356  	if iterationID != nil {
  2357  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2358  	}
  2359  
  2360  	preparer := autorest.CreatePreparer(
  2361  		autorest.AsGet(),
  2362  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2363  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  2364  		autorest.WithQueryParameters(queryParameters),
  2365  		autorest.WithHeader("Training-Key", client.APIKey))
  2366  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2367  }
  2368  
  2369  // GetTagSender sends the GetTag request. The method will close the
  2370  // http.Response Body if it receives an error.
  2371  func (client BaseClient) GetTagSender(req *http.Request) (*http.Response, error) {
  2372  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2373  }
  2374  
  2375  // GetTagResponder handles the response to the GetTag request. The method always
  2376  // closes the http.Response Body.
  2377  func (client BaseClient) GetTagResponder(resp *http.Response) (result Tag, err error) {
  2378  	err = autorest.Respond(
  2379  		resp,
  2380  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2381  		autorest.ByUnmarshallingJSON(&result),
  2382  		autorest.ByClosing())
  2383  	result.Response = autorest.Response{Response: resp}
  2384  	return
  2385  }
  2386  
  2387  // GetTaggedImageCount the filtering is on an and/or relationship. For example, if the provided tag ids are for the
  2388  // "Dog" and
  2389  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  2390  // Parameters:
  2391  // projectID - the project id.
  2392  // iterationID - the iteration id. Defaults to workspace.
  2393  // tagIds - a list of tags ids to filter the images to count. Defaults to all tags when null.
  2394  func (client BaseClient) GetTaggedImageCount(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []uuid.UUID) (result Int32, err error) {
  2395  	if tracing.IsEnabled() {
  2396  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTaggedImageCount")
  2397  		defer func() {
  2398  			sc := -1
  2399  			if result.Response.Response != nil {
  2400  				sc = result.Response.Response.StatusCode
  2401  			}
  2402  			tracing.EndSpan(ctx, sc, err)
  2403  		}()
  2404  	}
  2405  	req, err := client.GetTaggedImageCountPreparer(ctx, projectID, iterationID, tagIds)
  2406  	if err != nil {
  2407  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", nil, "Failure preparing request")
  2408  		return
  2409  	}
  2410  
  2411  	resp, err := client.GetTaggedImageCountSender(req)
  2412  	if err != nil {
  2413  		result.Response = autorest.Response{Response: resp}
  2414  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", resp, "Failure sending request")
  2415  		return
  2416  	}
  2417  
  2418  	result, err = client.GetTaggedImageCountResponder(resp)
  2419  	if err != nil {
  2420  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", resp, "Failure responding to request")
  2421  		return
  2422  	}
  2423  
  2424  	return
  2425  }
  2426  
  2427  // GetTaggedImageCountPreparer prepares the GetTaggedImageCount request.
  2428  func (client BaseClient) GetTaggedImageCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []uuid.UUID) (*http.Request, error) {
  2429  	urlParameters := map[string]interface{}{
  2430  		"Endpoint": client.Endpoint,
  2431  	}
  2432  
  2433  	pathParameters := map[string]interface{}{
  2434  		"projectId": autorest.Encode("path", projectID),
  2435  	}
  2436  
  2437  	queryParameters := map[string]interface{}{}
  2438  	if iterationID != nil {
  2439  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2440  	}
  2441  	if tagIds != nil && len(tagIds) > 0 {
  2442  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  2443  	}
  2444  
  2445  	preparer := autorest.CreatePreparer(
  2446  		autorest.AsGet(),
  2447  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2448  		autorest.WithPathParameters("/projects/{projectId}/images/tagged/count", pathParameters),
  2449  		autorest.WithQueryParameters(queryParameters),
  2450  		autorest.WithHeader("Training-Key", client.APIKey))
  2451  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2452  }
  2453  
  2454  // GetTaggedImageCountSender sends the GetTaggedImageCount request. The method will close the
  2455  // http.Response Body if it receives an error.
  2456  func (client BaseClient) GetTaggedImageCountSender(req *http.Request) (*http.Response, error) {
  2457  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2458  }
  2459  
  2460  // GetTaggedImageCountResponder handles the response to the GetTaggedImageCount request. The method always
  2461  // closes the http.Response Body.
  2462  func (client BaseClient) GetTaggedImageCountResponder(resp *http.Response) (result Int32, err error) {
  2463  	err = autorest.Respond(
  2464  		resp,
  2465  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2466  		autorest.ByUnmarshallingJSON(&result.Value),
  2467  		autorest.ByClosing())
  2468  	result.Response = autorest.Response{Response: resp}
  2469  	return
  2470  }
  2471  
  2472  // GetTaggedImages this API supports batching and range selection. By default it will only return first 50 images
  2473  // matching images.
  2474  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  2475  // The filtering is on an and/or relationship. For example, if the provided tag ids are for the "Dog" and
  2476  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  2477  // Parameters:
  2478  // projectID - the project id.
  2479  // iterationID - the iteration id. Defaults to workspace.
  2480  // tagIds - a list of tags ids to filter the images. Defaults to all tagged images when null. Limited to 20.
  2481  // orderBy - the ordering. Defaults to newest.
  2482  // take - maximum number of images to return. Defaults to 50, limited to 256.
  2483  // skip - number of images to skip before beginning the image batch. Defaults to 0.
  2484  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) {
  2485  	if tracing.IsEnabled() {
  2486  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTaggedImages")
  2487  		defer func() {
  2488  			sc := -1
  2489  			if result.Response.Response != nil {
  2490  				sc = result.Response.Response.StatusCode
  2491  			}
  2492  			tracing.EndSpan(ctx, sc, err)
  2493  		}()
  2494  	}
  2495  	if err := validation.Validate([]validation.Validation{
  2496  		{TargetValue: tagIds,
  2497  			Constraints: []validation.Constraint{{Target: "tagIds", Name: validation.Null, Rule: false,
  2498  				Chain: []validation.Constraint{{Target: "tagIds", Name: validation.MaxItems, Rule: 20, Chain: nil},
  2499  					{Target: "tagIds", Name: validation.MinItems, Rule: 0, Chain: nil},
  2500  				}}}},
  2501  		{TargetValue: take,
  2502  			Constraints: []validation.Constraint{{Target: "take", Name: validation.Null, Rule: false,
  2503  				Chain: []validation.Constraint{{Target: "take", Name: validation.InclusiveMaximum, Rule: int64(256), Chain: nil},
  2504  					{Target: "take", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil},
  2505  				}}}}}); err != nil {
  2506  		return result, validation.NewError("training.BaseClient", "GetTaggedImages", err.Error())
  2507  	}
  2508  
  2509  	req, err := client.GetTaggedImagesPreparer(ctx, projectID, iterationID, tagIds, orderBy, take, skip)
  2510  	if err != nil {
  2511  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", nil, "Failure preparing request")
  2512  		return
  2513  	}
  2514  
  2515  	resp, err := client.GetTaggedImagesSender(req)
  2516  	if err != nil {
  2517  		result.Response = autorest.Response{Response: resp}
  2518  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", resp, "Failure sending request")
  2519  		return
  2520  	}
  2521  
  2522  	result, err = client.GetTaggedImagesResponder(resp)
  2523  	if err != nil {
  2524  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", resp, "Failure responding to request")
  2525  		return
  2526  	}
  2527  
  2528  	return
  2529  }
  2530  
  2531  // GetTaggedImagesPreparer prepares the GetTaggedImages request.
  2532  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) {
  2533  	urlParameters := map[string]interface{}{
  2534  		"Endpoint": client.Endpoint,
  2535  	}
  2536  
  2537  	pathParameters := map[string]interface{}{
  2538  		"projectId": autorest.Encode("path", projectID),
  2539  	}
  2540  
  2541  	queryParameters := map[string]interface{}{}
  2542  	if iterationID != nil {
  2543  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2544  	}
  2545  	if tagIds != nil && len(tagIds) > 0 {
  2546  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  2547  	}
  2548  	if len(string(orderBy)) > 0 {
  2549  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  2550  	}
  2551  	if take != nil {
  2552  		queryParameters["take"] = autorest.Encode("query", *take)
  2553  	} else {
  2554  		queryParameters["take"] = autorest.Encode("query", 50)
  2555  	}
  2556  	if skip != nil {
  2557  		queryParameters["skip"] = autorest.Encode("query", *skip)
  2558  	} else {
  2559  		queryParameters["skip"] = autorest.Encode("query", 0)
  2560  	}
  2561  
  2562  	preparer := autorest.CreatePreparer(
  2563  		autorest.AsGet(),
  2564  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2565  		autorest.WithPathParameters("/projects/{projectId}/images/tagged", pathParameters),
  2566  		autorest.WithQueryParameters(queryParameters),
  2567  		autorest.WithHeader("Training-Key", client.APIKey))
  2568  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2569  }
  2570  
  2571  // GetTaggedImagesSender sends the GetTaggedImages request. The method will close the
  2572  // http.Response Body if it receives an error.
  2573  func (client BaseClient) GetTaggedImagesSender(req *http.Request) (*http.Response, error) {
  2574  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2575  }
  2576  
  2577  // GetTaggedImagesResponder handles the response to the GetTaggedImages request. The method always
  2578  // closes the http.Response Body.
  2579  func (client BaseClient) GetTaggedImagesResponder(resp *http.Response) (result ListImage, err error) {
  2580  	err = autorest.Respond(
  2581  		resp,
  2582  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2583  		autorest.ByUnmarshallingJSON(&result.Value),
  2584  		autorest.ByClosing())
  2585  	result.Response = autorest.Response{Response: resp}
  2586  	return
  2587  }
  2588  
  2589  // GetTags sends the get tags request.
  2590  // Parameters:
  2591  // projectID - the project id.
  2592  // iterationID - the iteration id. Defaults to workspace.
  2593  func (client BaseClient) GetTags(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (result ListTag, err error) {
  2594  	if tracing.IsEnabled() {
  2595  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTags")
  2596  		defer func() {
  2597  			sc := -1
  2598  			if result.Response.Response != nil {
  2599  				sc = result.Response.Response.StatusCode
  2600  			}
  2601  			tracing.EndSpan(ctx, sc, err)
  2602  		}()
  2603  	}
  2604  	req, err := client.GetTagsPreparer(ctx, projectID, iterationID)
  2605  	if err != nil {
  2606  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", nil, "Failure preparing request")
  2607  		return
  2608  	}
  2609  
  2610  	resp, err := client.GetTagsSender(req)
  2611  	if err != nil {
  2612  		result.Response = autorest.Response{Response: resp}
  2613  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", resp, "Failure sending request")
  2614  		return
  2615  	}
  2616  
  2617  	result, err = client.GetTagsResponder(resp)
  2618  	if err != nil {
  2619  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", resp, "Failure responding to request")
  2620  		return
  2621  	}
  2622  
  2623  	return
  2624  }
  2625  
  2626  // GetTagsPreparer prepares the GetTags request.
  2627  func (client BaseClient) GetTagsPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2628  	urlParameters := map[string]interface{}{
  2629  		"Endpoint": client.Endpoint,
  2630  	}
  2631  
  2632  	pathParameters := map[string]interface{}{
  2633  		"projectId": autorest.Encode("path", projectID),
  2634  	}
  2635  
  2636  	queryParameters := map[string]interface{}{}
  2637  	if iterationID != nil {
  2638  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2639  	}
  2640  
  2641  	preparer := autorest.CreatePreparer(
  2642  		autorest.AsGet(),
  2643  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2644  		autorest.WithPathParameters("/projects/{projectId}/tags", pathParameters),
  2645  		autorest.WithQueryParameters(queryParameters),
  2646  		autorest.WithHeader("Training-Key", client.APIKey))
  2647  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2648  }
  2649  
  2650  // GetTagsSender sends the GetTags request. The method will close the
  2651  // http.Response Body if it receives an error.
  2652  func (client BaseClient) GetTagsSender(req *http.Request) (*http.Response, error) {
  2653  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2654  }
  2655  
  2656  // GetTagsResponder handles the response to the GetTags request. The method always
  2657  // closes the http.Response Body.
  2658  func (client BaseClient) GetTagsResponder(resp *http.Response) (result ListTag, err error) {
  2659  	err = autorest.Respond(
  2660  		resp,
  2661  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2662  		autorest.ByUnmarshallingJSON(&result.Value),
  2663  		autorest.ByClosing())
  2664  	result.Response = autorest.Response{Response: resp}
  2665  	return
  2666  }
  2667  
  2668  // GetUntaggedImageCount this API returns the images which have no tags for a given project and optionally an
  2669  // iteration. If no iteration is specified the
  2670  // current workspace is used.
  2671  // Parameters:
  2672  // projectID - the project id.
  2673  // iterationID - the iteration id. Defaults to workspace.
  2674  func (client BaseClient) GetUntaggedImageCount(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (result Int32, err error) {
  2675  	if tracing.IsEnabled() {
  2676  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetUntaggedImageCount")
  2677  		defer func() {
  2678  			sc := -1
  2679  			if result.Response.Response != nil {
  2680  				sc = result.Response.Response.StatusCode
  2681  			}
  2682  			tracing.EndSpan(ctx, sc, err)
  2683  		}()
  2684  	}
  2685  	req, err := client.GetUntaggedImageCountPreparer(ctx, projectID, iterationID)
  2686  	if err != nil {
  2687  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", nil, "Failure preparing request")
  2688  		return
  2689  	}
  2690  
  2691  	resp, err := client.GetUntaggedImageCountSender(req)
  2692  	if err != nil {
  2693  		result.Response = autorest.Response{Response: resp}
  2694  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", resp, "Failure sending request")
  2695  		return
  2696  	}
  2697  
  2698  	result, err = client.GetUntaggedImageCountResponder(resp)
  2699  	if err != nil {
  2700  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", resp, "Failure responding to request")
  2701  		return
  2702  	}
  2703  
  2704  	return
  2705  }
  2706  
  2707  // GetUntaggedImageCountPreparer prepares the GetUntaggedImageCount request.
  2708  func (client BaseClient) GetUntaggedImageCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2709  	urlParameters := map[string]interface{}{
  2710  		"Endpoint": client.Endpoint,
  2711  	}
  2712  
  2713  	pathParameters := map[string]interface{}{
  2714  		"projectId": autorest.Encode("path", projectID),
  2715  	}
  2716  
  2717  	queryParameters := map[string]interface{}{}
  2718  	if iterationID != nil {
  2719  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2720  	}
  2721  
  2722  	preparer := autorest.CreatePreparer(
  2723  		autorest.AsGet(),
  2724  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2725  		autorest.WithPathParameters("/projects/{projectId}/images/untagged/count", pathParameters),
  2726  		autorest.WithQueryParameters(queryParameters),
  2727  		autorest.WithHeader("Training-Key", client.APIKey))
  2728  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2729  }
  2730  
  2731  // GetUntaggedImageCountSender sends the GetUntaggedImageCount request. The method will close the
  2732  // http.Response Body if it receives an error.
  2733  func (client BaseClient) GetUntaggedImageCountSender(req *http.Request) (*http.Response, error) {
  2734  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2735  }
  2736  
  2737  // GetUntaggedImageCountResponder handles the response to the GetUntaggedImageCount request. The method always
  2738  // closes the http.Response Body.
  2739  func (client BaseClient) GetUntaggedImageCountResponder(resp *http.Response) (result Int32, err error) {
  2740  	err = autorest.Respond(
  2741  		resp,
  2742  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2743  		autorest.ByUnmarshallingJSON(&result.Value),
  2744  		autorest.ByClosing())
  2745  	result.Response = autorest.Response{Response: resp}
  2746  	return
  2747  }
  2748  
  2749  // GetUntaggedImages this API supports batching and range selection. By default it will only return first 50 images
  2750  // matching images.
  2751  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  2752  // Parameters:
  2753  // projectID - the project id.
  2754  // iterationID - the iteration id. Defaults to workspace.
  2755  // orderBy - the ordering. Defaults to newest.
  2756  // take - maximum number of images to return. Defaults to 50, limited to 256.
  2757  // skip - number of images to skip before beginning the image batch. Defaults to 0.
  2758  func (client BaseClient) GetUntaggedImages(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, orderBy string, take *int32, skip *int32) (result ListImage, err error) {
  2759  	if tracing.IsEnabled() {
  2760  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetUntaggedImages")
  2761  		defer func() {
  2762  			sc := -1
  2763  			if result.Response.Response != nil {
  2764  				sc = result.Response.Response.StatusCode
  2765  			}
  2766  			tracing.EndSpan(ctx, sc, err)
  2767  		}()
  2768  	}
  2769  	if err := validation.Validate([]validation.Validation{
  2770  		{TargetValue: take,
  2771  			Constraints: []validation.Constraint{{Target: "take", Name: validation.Null, Rule: false,
  2772  				Chain: []validation.Constraint{{Target: "take", Name: validation.InclusiveMaximum, Rule: int64(256), Chain: nil},
  2773  					{Target: "take", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil},
  2774  				}}}}}); err != nil {
  2775  		return result, validation.NewError("training.BaseClient", "GetUntaggedImages", err.Error())
  2776  	}
  2777  
  2778  	req, err := client.GetUntaggedImagesPreparer(ctx, projectID, iterationID, orderBy, take, skip)
  2779  	if err != nil {
  2780  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", nil, "Failure preparing request")
  2781  		return
  2782  	}
  2783  
  2784  	resp, err := client.GetUntaggedImagesSender(req)
  2785  	if err != nil {
  2786  		result.Response = autorest.Response{Response: resp}
  2787  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", resp, "Failure sending request")
  2788  		return
  2789  	}
  2790  
  2791  	result, err = client.GetUntaggedImagesResponder(resp)
  2792  	if err != nil {
  2793  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", resp, "Failure responding to request")
  2794  		return
  2795  	}
  2796  
  2797  	return
  2798  }
  2799  
  2800  // GetUntaggedImagesPreparer prepares the GetUntaggedImages request.
  2801  func (client BaseClient) GetUntaggedImagesPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, orderBy string, take *int32, skip *int32) (*http.Request, error) {
  2802  	urlParameters := map[string]interface{}{
  2803  		"Endpoint": client.Endpoint,
  2804  	}
  2805  
  2806  	pathParameters := map[string]interface{}{
  2807  		"projectId": autorest.Encode("path", projectID),
  2808  	}
  2809  
  2810  	queryParameters := map[string]interface{}{}
  2811  	if iterationID != nil {
  2812  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2813  	}
  2814  	if len(string(orderBy)) > 0 {
  2815  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  2816  	}
  2817  	if take != nil {
  2818  		queryParameters["take"] = autorest.Encode("query", *take)
  2819  	} else {
  2820  		queryParameters["take"] = autorest.Encode("query", 50)
  2821  	}
  2822  	if skip != nil {
  2823  		queryParameters["skip"] = autorest.Encode("query", *skip)
  2824  	} else {
  2825  		queryParameters["skip"] = autorest.Encode("query", 0)
  2826  	}
  2827  
  2828  	preparer := autorest.CreatePreparer(
  2829  		autorest.AsGet(),
  2830  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2831  		autorest.WithPathParameters("/projects/{projectId}/images/untagged", pathParameters),
  2832  		autorest.WithQueryParameters(queryParameters),
  2833  		autorest.WithHeader("Training-Key", client.APIKey))
  2834  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2835  }
  2836  
  2837  // GetUntaggedImagesSender sends the GetUntaggedImages request. The method will close the
  2838  // http.Response Body if it receives an error.
  2839  func (client BaseClient) GetUntaggedImagesSender(req *http.Request) (*http.Response, error) {
  2840  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2841  }
  2842  
  2843  // GetUntaggedImagesResponder handles the response to the GetUntaggedImages request. The method always
  2844  // closes the http.Response Body.
  2845  func (client BaseClient) GetUntaggedImagesResponder(resp *http.Response) (result ListImage, err error) {
  2846  	err = autorest.Respond(
  2847  		resp,
  2848  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2849  		autorest.ByUnmarshallingJSON(&result.Value),
  2850  		autorest.ByClosing())
  2851  	result.Response = autorest.Response{Response: resp}
  2852  	return
  2853  }
  2854  
  2855  // PublishIteration sends the publish iteration request.
  2856  // Parameters:
  2857  // projectID - the project id.
  2858  // iterationID - the iteration id.
  2859  // publishName - the name to give the published iteration.
  2860  // predictionID - the id of the prediction resource to publish to.
  2861  func (client BaseClient) PublishIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, publishName string, predictionID string) (result Bool, err error) {
  2862  	if tracing.IsEnabled() {
  2863  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.PublishIteration")
  2864  		defer func() {
  2865  			sc := -1
  2866  			if result.Response.Response != nil {
  2867  				sc = result.Response.Response.StatusCode
  2868  			}
  2869  			tracing.EndSpan(ctx, sc, err)
  2870  		}()
  2871  	}
  2872  	req, err := client.PublishIterationPreparer(ctx, projectID, iterationID, publishName, predictionID)
  2873  	if err != nil {
  2874  		err = autorest.NewErrorWithError(err, "training.BaseClient", "PublishIteration", nil, "Failure preparing request")
  2875  		return
  2876  	}
  2877  
  2878  	resp, err := client.PublishIterationSender(req)
  2879  	if err != nil {
  2880  		result.Response = autorest.Response{Response: resp}
  2881  		err = autorest.NewErrorWithError(err, "training.BaseClient", "PublishIteration", resp, "Failure sending request")
  2882  		return
  2883  	}
  2884  
  2885  	result, err = client.PublishIterationResponder(resp)
  2886  	if err != nil {
  2887  		err = autorest.NewErrorWithError(err, "training.BaseClient", "PublishIteration", resp, "Failure responding to request")
  2888  		return
  2889  	}
  2890  
  2891  	return
  2892  }
  2893  
  2894  // PublishIterationPreparer prepares the PublishIteration request.
  2895  func (client BaseClient) PublishIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, publishName string, predictionID string) (*http.Request, error) {
  2896  	urlParameters := map[string]interface{}{
  2897  		"Endpoint": client.Endpoint,
  2898  	}
  2899  
  2900  	pathParameters := map[string]interface{}{
  2901  		"iterationId": autorest.Encode("path", iterationID),
  2902  		"projectId":   autorest.Encode("path", projectID),
  2903  	}
  2904  
  2905  	queryParameters := map[string]interface{}{
  2906  		"predictionId": autorest.Encode("query", predictionID),
  2907  		"publishName":  autorest.Encode("query", publishName),
  2908  	}
  2909  
  2910  	preparer := autorest.CreatePreparer(
  2911  		autorest.AsPost(),
  2912  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2913  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/publish", pathParameters),
  2914  		autorest.WithQueryParameters(queryParameters),
  2915  		autorest.WithHeader("Training-Key", client.APIKey))
  2916  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2917  }
  2918  
  2919  // PublishIterationSender sends the PublishIteration request. The method will close the
  2920  // http.Response Body if it receives an error.
  2921  func (client BaseClient) PublishIterationSender(req *http.Request) (*http.Response, error) {
  2922  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2923  }
  2924  
  2925  // PublishIterationResponder handles the response to the PublishIteration request. The method always
  2926  // closes the http.Response Body.
  2927  func (client BaseClient) PublishIterationResponder(resp *http.Response) (result Bool, err error) {
  2928  	err = autorest.Respond(
  2929  		resp,
  2930  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2931  		autorest.ByUnmarshallingJSON(&result.Value),
  2932  		autorest.ByClosing())
  2933  	result.Response = autorest.Response{Response: resp}
  2934  	return
  2935  }
  2936  
  2937  // QueryPredictions sends the query predictions request.
  2938  // Parameters:
  2939  // projectID - the project id.
  2940  // query - parameters used to query the predictions. Limited to combining 2 tags.
  2941  func (client BaseClient) QueryPredictions(ctx context.Context, projectID uuid.UUID, query PredictionQueryToken) (result PredictionQueryResult, err error) {
  2942  	if tracing.IsEnabled() {
  2943  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QueryPredictions")
  2944  		defer func() {
  2945  			sc := -1
  2946  			if result.Response.Response != nil {
  2947  				sc = result.Response.Response.StatusCode
  2948  			}
  2949  			tracing.EndSpan(ctx, sc, err)
  2950  		}()
  2951  	}
  2952  	req, err := client.QueryPredictionsPreparer(ctx, projectID, query)
  2953  	if err != nil {
  2954  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", nil, "Failure preparing request")
  2955  		return
  2956  	}
  2957  
  2958  	resp, err := client.QueryPredictionsSender(req)
  2959  	if err != nil {
  2960  		result.Response = autorest.Response{Response: resp}
  2961  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", resp, "Failure sending request")
  2962  		return
  2963  	}
  2964  
  2965  	result, err = client.QueryPredictionsResponder(resp)
  2966  	if err != nil {
  2967  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", resp, "Failure responding to request")
  2968  		return
  2969  	}
  2970  
  2971  	return
  2972  }
  2973  
  2974  // QueryPredictionsPreparer prepares the QueryPredictions request.
  2975  func (client BaseClient) QueryPredictionsPreparer(ctx context.Context, projectID uuid.UUID, query PredictionQueryToken) (*http.Request, error) {
  2976  	urlParameters := map[string]interface{}{
  2977  		"Endpoint": client.Endpoint,
  2978  	}
  2979  
  2980  	pathParameters := map[string]interface{}{
  2981  		"projectId": autorest.Encode("path", projectID),
  2982  	}
  2983  
  2984  	preparer := autorest.CreatePreparer(
  2985  		autorest.AsContentType("application/json; charset=utf-8"),
  2986  		autorest.AsPost(),
  2987  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  2988  		autorest.WithPathParameters("/projects/{projectId}/predictions/query", pathParameters),
  2989  		autorest.WithJSON(query),
  2990  		autorest.WithHeader("Training-Key", client.APIKey))
  2991  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2992  }
  2993  
  2994  // QueryPredictionsSender sends the QueryPredictions request. The method will close the
  2995  // http.Response Body if it receives an error.
  2996  func (client BaseClient) QueryPredictionsSender(req *http.Request) (*http.Response, error) {
  2997  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2998  }
  2999  
  3000  // QueryPredictionsResponder handles the response to the QueryPredictions request. The method always
  3001  // closes the http.Response Body.
  3002  func (client BaseClient) QueryPredictionsResponder(resp *http.Response) (result PredictionQueryResult, err error) {
  3003  	err = autorest.Respond(
  3004  		resp,
  3005  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3006  		autorest.ByUnmarshallingJSON(&result),
  3007  		autorest.ByClosing())
  3008  	result.Response = autorest.Response{Response: resp}
  3009  	return
  3010  }
  3011  
  3012  // QuerySuggestedImageCount this API takes in tagIds to get count of untagged images per suggested tags for a given
  3013  // threshold.
  3014  // Parameters:
  3015  // projectID - the project id.
  3016  // iterationID - iterationId to use for the suggested tags and regions.
  3017  // query - model that contains tagIds, threshold and projectType to query by.
  3018  func (client BaseClient) QuerySuggestedImageCount(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, query TagFilter) (result SetInt32, err error) {
  3019  	if tracing.IsEnabled() {
  3020  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuerySuggestedImageCount")
  3021  		defer func() {
  3022  			sc := -1
  3023  			if result.Response.Response != nil {
  3024  				sc = result.Response.Response.StatusCode
  3025  			}
  3026  			tracing.EndSpan(ctx, sc, err)
  3027  		}()
  3028  	}
  3029  	req, err := client.QuerySuggestedImageCountPreparer(ctx, projectID, iterationID, query)
  3030  	if err != nil {
  3031  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuerySuggestedImageCount", nil, "Failure preparing request")
  3032  		return
  3033  	}
  3034  
  3035  	resp, err := client.QuerySuggestedImageCountSender(req)
  3036  	if err != nil {
  3037  		result.Response = autorest.Response{Response: resp}
  3038  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuerySuggestedImageCount", resp, "Failure sending request")
  3039  		return
  3040  	}
  3041  
  3042  	result, err = client.QuerySuggestedImageCountResponder(resp)
  3043  	if err != nil {
  3044  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuerySuggestedImageCount", resp, "Failure responding to request")
  3045  		return
  3046  	}
  3047  
  3048  	return
  3049  }
  3050  
  3051  // QuerySuggestedImageCountPreparer prepares the QuerySuggestedImageCount request.
  3052  func (client BaseClient) QuerySuggestedImageCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, query TagFilter) (*http.Request, error) {
  3053  	urlParameters := map[string]interface{}{
  3054  		"Endpoint": client.Endpoint,
  3055  	}
  3056  
  3057  	pathParameters := map[string]interface{}{
  3058  		"projectId": autorest.Encode("path", projectID),
  3059  	}
  3060  
  3061  	queryParameters := map[string]interface{}{
  3062  		"iterationId": autorest.Encode("query", iterationID),
  3063  	}
  3064  
  3065  	preparer := autorest.CreatePreparer(
  3066  		autorest.AsContentType("application/json; charset=utf-8"),
  3067  		autorest.AsPost(),
  3068  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3069  		autorest.WithPathParameters("/projects/{projectId}/images/suggested/count", pathParameters),
  3070  		autorest.WithJSON(query),
  3071  		autorest.WithQueryParameters(queryParameters),
  3072  		autorest.WithHeader("Training-Key", client.APIKey))
  3073  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3074  }
  3075  
  3076  // QuerySuggestedImageCountSender sends the QuerySuggestedImageCount request. The method will close the
  3077  // http.Response Body if it receives an error.
  3078  func (client BaseClient) QuerySuggestedImageCountSender(req *http.Request) (*http.Response, error) {
  3079  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3080  }
  3081  
  3082  // QuerySuggestedImageCountResponder handles the response to the QuerySuggestedImageCount request. The method always
  3083  // closes the http.Response Body.
  3084  func (client BaseClient) QuerySuggestedImageCountResponder(resp *http.Response) (result SetInt32, err error) {
  3085  	err = autorest.Respond(
  3086  		resp,
  3087  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3088  		autorest.ByUnmarshallingJSON(&result.Value),
  3089  		autorest.ByClosing())
  3090  	result.Response = autorest.Response{Response: resp}
  3091  	return
  3092  }
  3093  
  3094  // QuerySuggestedImages this API will fetch untagged images filtered by suggested tags Ids. It returns an empty array
  3095  // if no images are found.
  3096  // Parameters:
  3097  // projectID - the project id.
  3098  // iterationID - iterationId to use for the suggested tags and regions.
  3099  // query - contains properties we need to query suggested images.
  3100  func (client BaseClient) QuerySuggestedImages(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, query SuggestedTagAndRegionQueryToken) (result SuggestedTagAndRegionQuery, err error) {
  3101  	if tracing.IsEnabled() {
  3102  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuerySuggestedImages")
  3103  		defer func() {
  3104  			sc := -1
  3105  			if result.Response.Response != nil {
  3106  				sc = result.Response.Response.StatusCode
  3107  			}
  3108  			tracing.EndSpan(ctx, sc, err)
  3109  		}()
  3110  	}
  3111  	req, err := client.QuerySuggestedImagesPreparer(ctx, projectID, iterationID, query)
  3112  	if err != nil {
  3113  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuerySuggestedImages", nil, "Failure preparing request")
  3114  		return
  3115  	}
  3116  
  3117  	resp, err := client.QuerySuggestedImagesSender(req)
  3118  	if err != nil {
  3119  		result.Response = autorest.Response{Response: resp}
  3120  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuerySuggestedImages", resp, "Failure sending request")
  3121  		return
  3122  	}
  3123  
  3124  	result, err = client.QuerySuggestedImagesResponder(resp)
  3125  	if err != nil {
  3126  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuerySuggestedImages", resp, "Failure responding to request")
  3127  		return
  3128  	}
  3129  
  3130  	return
  3131  }
  3132  
  3133  // QuerySuggestedImagesPreparer prepares the QuerySuggestedImages request.
  3134  func (client BaseClient) QuerySuggestedImagesPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, query SuggestedTagAndRegionQueryToken) (*http.Request, error) {
  3135  	urlParameters := map[string]interface{}{
  3136  		"Endpoint": client.Endpoint,
  3137  	}
  3138  
  3139  	pathParameters := map[string]interface{}{
  3140  		"projectId": autorest.Encode("path", projectID),
  3141  	}
  3142  
  3143  	queryParameters := map[string]interface{}{
  3144  		"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.1/training", urlParameters),
  3151  		autorest.WithPathParameters("/projects/{projectId}/images/suggested", pathParameters),
  3152  		autorest.WithJSON(query),
  3153  		autorest.WithQueryParameters(queryParameters),
  3154  		autorest.WithHeader("Training-Key", client.APIKey))
  3155  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3156  }
  3157  
  3158  // QuerySuggestedImagesSender sends the QuerySuggestedImages request. The method will close the
  3159  // http.Response Body if it receives an error.
  3160  func (client BaseClient) QuerySuggestedImagesSender(req *http.Request) (*http.Response, error) {
  3161  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3162  }
  3163  
  3164  // QuerySuggestedImagesResponder handles the response to the QuerySuggestedImages request. The method always
  3165  // closes the http.Response Body.
  3166  func (client BaseClient) QuerySuggestedImagesResponder(resp *http.Response) (result SuggestedTagAndRegionQuery, 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  // QuickTestImage sends the quick test image request.
  3177  // Parameters:
  3178  // projectID - the project id.
  3179  // imageData - binary image data. Supported formats are JPEG, GIF, PNG, and BMP. Supports images up to 6MB.
  3180  // iterationID - optional. Specifies the id of a particular iteration to evaluate against.
  3181  // The default iteration for the project will be used when not specified.
  3182  // store - optional. Specifies whether or not to store the result of this prediction. The default is true, to
  3183  // store.
  3184  func (client BaseClient) QuickTestImage(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, iterationID *uuid.UUID, store *bool) (result ImagePrediction, err error) {
  3185  	if tracing.IsEnabled() {
  3186  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuickTestImage")
  3187  		defer func() {
  3188  			sc := -1
  3189  			if result.Response.Response != nil {
  3190  				sc = result.Response.Response.StatusCode
  3191  			}
  3192  			tracing.EndSpan(ctx, sc, err)
  3193  		}()
  3194  	}
  3195  	req, err := client.QuickTestImagePreparer(ctx, projectID, imageData, iterationID, store)
  3196  	if err != nil {
  3197  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", nil, "Failure preparing request")
  3198  		return
  3199  	}
  3200  
  3201  	resp, err := client.QuickTestImageSender(req)
  3202  	if err != nil {
  3203  		result.Response = autorest.Response{Response: resp}
  3204  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", resp, "Failure sending request")
  3205  		return
  3206  	}
  3207  
  3208  	result, err = client.QuickTestImageResponder(resp)
  3209  	if err != nil {
  3210  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", resp, "Failure responding to request")
  3211  		return
  3212  	}
  3213  
  3214  	return
  3215  }
  3216  
  3217  // QuickTestImagePreparer prepares the QuickTestImage request.
  3218  func (client BaseClient) QuickTestImagePreparer(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, iterationID *uuid.UUID, store *bool) (*http.Request, error) {
  3219  	urlParameters := map[string]interface{}{
  3220  		"Endpoint": client.Endpoint,
  3221  	}
  3222  
  3223  	pathParameters := map[string]interface{}{
  3224  		"projectId": autorest.Encode("path", projectID),
  3225  	}
  3226  
  3227  	queryParameters := map[string]interface{}{}
  3228  	if iterationID != nil {
  3229  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  3230  	}
  3231  	if store != nil {
  3232  		queryParameters["store"] = autorest.Encode("query", *store)
  3233  	} else {
  3234  		queryParameters["store"] = autorest.Encode("query", true)
  3235  	}
  3236  
  3237  	formDataParameters := map[string]interface{}{
  3238  		"imageData": imageData,
  3239  	}
  3240  
  3241  	preparer := autorest.CreatePreparer(
  3242  		autorest.AsPost(),
  3243  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3244  		autorest.WithPathParameters("/projects/{projectId}/quicktest/image", pathParameters),
  3245  		autorest.WithQueryParameters(queryParameters),
  3246  		autorest.WithMultiPartFormData(formDataParameters),
  3247  		autorest.WithHeader("Training-Key", client.APIKey))
  3248  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3249  }
  3250  
  3251  // QuickTestImageSender sends the QuickTestImage request. The method will close the
  3252  // http.Response Body if it receives an error.
  3253  func (client BaseClient) QuickTestImageSender(req *http.Request) (*http.Response, error) {
  3254  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3255  }
  3256  
  3257  // QuickTestImageResponder handles the response to the QuickTestImage request. The method always
  3258  // closes the http.Response Body.
  3259  func (client BaseClient) QuickTestImageResponder(resp *http.Response) (result ImagePrediction, err error) {
  3260  	err = autorest.Respond(
  3261  		resp,
  3262  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3263  		autorest.ByUnmarshallingJSON(&result),
  3264  		autorest.ByClosing())
  3265  	result.Response = autorest.Response{Response: resp}
  3266  	return
  3267  }
  3268  
  3269  // QuickTestImageURL sends the quick test image url request.
  3270  // Parameters:
  3271  // projectID - the project to evaluate against.
  3272  // imageURL - an ImageUrl that contains the url of the image to be evaluated.
  3273  // iterationID - optional. Specifies the id of a particular iteration to evaluate against.
  3274  // The default iteration for the project will be used when not specified.
  3275  // store - optional. Specifies whether or not to store the result of this prediction. The default is true, to
  3276  // store.
  3277  func (client BaseClient) QuickTestImageURL(ctx context.Context, projectID uuid.UUID, imageURL ImageURL, iterationID *uuid.UUID, store *bool) (result ImagePrediction, err error) {
  3278  	if tracing.IsEnabled() {
  3279  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuickTestImageURL")
  3280  		defer func() {
  3281  			sc := -1
  3282  			if result.Response.Response != nil {
  3283  				sc = result.Response.Response.StatusCode
  3284  			}
  3285  			tracing.EndSpan(ctx, sc, err)
  3286  		}()
  3287  	}
  3288  	if err := validation.Validate([]validation.Validation{
  3289  		{TargetValue: imageURL,
  3290  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  3291  		return result, validation.NewError("training.BaseClient", "QuickTestImageURL", err.Error())
  3292  	}
  3293  
  3294  	req, err := client.QuickTestImageURLPreparer(ctx, projectID, imageURL, iterationID, store)
  3295  	if err != nil {
  3296  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", nil, "Failure preparing request")
  3297  		return
  3298  	}
  3299  
  3300  	resp, err := client.QuickTestImageURLSender(req)
  3301  	if err != nil {
  3302  		result.Response = autorest.Response{Response: resp}
  3303  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", resp, "Failure sending request")
  3304  		return
  3305  	}
  3306  
  3307  	result, err = client.QuickTestImageURLResponder(resp)
  3308  	if err != nil {
  3309  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", resp, "Failure responding to request")
  3310  		return
  3311  	}
  3312  
  3313  	return
  3314  }
  3315  
  3316  // QuickTestImageURLPreparer prepares the QuickTestImageURL request.
  3317  func (client BaseClient) QuickTestImageURLPreparer(ctx context.Context, projectID uuid.UUID, imageURL ImageURL, iterationID *uuid.UUID, store *bool) (*http.Request, error) {
  3318  	urlParameters := map[string]interface{}{
  3319  		"Endpoint": client.Endpoint,
  3320  	}
  3321  
  3322  	pathParameters := map[string]interface{}{
  3323  		"projectId": autorest.Encode("path", projectID),
  3324  	}
  3325  
  3326  	queryParameters := map[string]interface{}{}
  3327  	if iterationID != nil {
  3328  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  3329  	}
  3330  	if store != nil {
  3331  		queryParameters["store"] = autorest.Encode("query", *store)
  3332  	} else {
  3333  		queryParameters["store"] = autorest.Encode("query", true)
  3334  	}
  3335  
  3336  	preparer := autorest.CreatePreparer(
  3337  		autorest.AsContentType("application/json; charset=utf-8"),
  3338  		autorest.AsPost(),
  3339  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3340  		autorest.WithPathParameters("/projects/{projectId}/quicktest/url", pathParameters),
  3341  		autorest.WithJSON(imageURL),
  3342  		autorest.WithQueryParameters(queryParameters),
  3343  		autorest.WithHeader("Training-Key", client.APIKey))
  3344  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3345  }
  3346  
  3347  // QuickTestImageURLSender sends the QuickTestImageURL request. The method will close the
  3348  // http.Response Body if it receives an error.
  3349  func (client BaseClient) QuickTestImageURLSender(req *http.Request) (*http.Response, error) {
  3350  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3351  }
  3352  
  3353  // QuickTestImageURLResponder handles the response to the QuickTestImageURL request. The method always
  3354  // closes the http.Response Body.
  3355  func (client BaseClient) QuickTestImageURLResponder(resp *http.Response) (result ImagePrediction, err error) {
  3356  	err = autorest.Respond(
  3357  		resp,
  3358  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3359  		autorest.ByUnmarshallingJSON(&result),
  3360  		autorest.ByClosing())
  3361  	result.Response = autorest.Response{Response: resp}
  3362  	return
  3363  }
  3364  
  3365  // SuggestTagsAndRegions this API will get suggested tags and regions for an array/batch of untagged images along with
  3366  // confidences for the tags. It returns an empty array if no tags are found.
  3367  // There is a limit of 64 images in the batch.
  3368  // Parameters:
  3369  // projectID - the project id.
  3370  // iterationID - iterationId to use for tag and region suggestion.
  3371  // imageIds - array of image ids tag suggestion are needed for. Use GetUntaggedImages API to get imageIds.
  3372  func (client BaseClient) SuggestTagsAndRegions(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, imageIds []uuid.UUID) (result ListSuggestedTagAndRegion, err error) {
  3373  	if tracing.IsEnabled() {
  3374  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.SuggestTagsAndRegions")
  3375  		defer func() {
  3376  			sc := -1
  3377  			if result.Response.Response != nil {
  3378  				sc = result.Response.Response.StatusCode
  3379  			}
  3380  			tracing.EndSpan(ctx, sc, err)
  3381  		}()
  3382  	}
  3383  	if err := validation.Validate([]validation.Validation{
  3384  		{TargetValue: imageIds,
  3385  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: true,
  3386  				Chain: []validation.Constraint{{Target: "imageIds", Name: validation.MaxItems, Rule: 64, Chain: nil},
  3387  					{Target: "imageIds", Name: validation.MinItems, Rule: 0, Chain: nil},
  3388  				}}}}}); err != nil {
  3389  		return result, validation.NewError("training.BaseClient", "SuggestTagsAndRegions", err.Error())
  3390  	}
  3391  
  3392  	req, err := client.SuggestTagsAndRegionsPreparer(ctx, projectID, iterationID, imageIds)
  3393  	if err != nil {
  3394  		err = autorest.NewErrorWithError(err, "training.BaseClient", "SuggestTagsAndRegions", nil, "Failure preparing request")
  3395  		return
  3396  	}
  3397  
  3398  	resp, err := client.SuggestTagsAndRegionsSender(req)
  3399  	if err != nil {
  3400  		result.Response = autorest.Response{Response: resp}
  3401  		err = autorest.NewErrorWithError(err, "training.BaseClient", "SuggestTagsAndRegions", resp, "Failure sending request")
  3402  		return
  3403  	}
  3404  
  3405  	result, err = client.SuggestTagsAndRegionsResponder(resp)
  3406  	if err != nil {
  3407  		err = autorest.NewErrorWithError(err, "training.BaseClient", "SuggestTagsAndRegions", resp, "Failure responding to request")
  3408  		return
  3409  	}
  3410  
  3411  	return
  3412  }
  3413  
  3414  // SuggestTagsAndRegionsPreparer prepares the SuggestTagsAndRegions request.
  3415  func (client BaseClient) SuggestTagsAndRegionsPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, imageIds []uuid.UUID) (*http.Request, error) {
  3416  	urlParameters := map[string]interface{}{
  3417  		"Endpoint": client.Endpoint,
  3418  	}
  3419  
  3420  	pathParameters := map[string]interface{}{
  3421  		"projectId": autorest.Encode("path", projectID),
  3422  	}
  3423  
  3424  	queryParameters := map[string]interface{}{
  3425  		"imageIds":    autorest.Encode("query", imageIds, ","),
  3426  		"iterationId": autorest.Encode("query", iterationID),
  3427  	}
  3428  
  3429  	preparer := autorest.CreatePreparer(
  3430  		autorest.AsPost(),
  3431  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3432  		autorest.WithPathParameters("/projects/{projectId}/tagsandregions/suggestions", pathParameters),
  3433  		autorest.WithQueryParameters(queryParameters),
  3434  		autorest.WithHeader("Training-Key", client.APIKey))
  3435  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3436  }
  3437  
  3438  // SuggestTagsAndRegionsSender sends the SuggestTagsAndRegions request. The method will close the
  3439  // http.Response Body if it receives an error.
  3440  func (client BaseClient) SuggestTagsAndRegionsSender(req *http.Request) (*http.Response, error) {
  3441  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3442  }
  3443  
  3444  // SuggestTagsAndRegionsResponder handles the response to the SuggestTagsAndRegions request. The method always
  3445  // closes the http.Response Body.
  3446  func (client BaseClient) SuggestTagsAndRegionsResponder(resp *http.Response) (result ListSuggestedTagAndRegion, err error) {
  3447  	err = autorest.Respond(
  3448  		resp,
  3449  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3450  		autorest.ByUnmarshallingJSON(&result.Value),
  3451  		autorest.ByClosing())
  3452  	result.Response = autorest.Response{Response: resp}
  3453  	return
  3454  }
  3455  
  3456  // TrainProject sends the train project request.
  3457  // Parameters:
  3458  // projectID - the project id.
  3459  // trainingType - the type of training to use to train the project (default: Regular).
  3460  // reservedBudgetInHours - the number of hours reserved as budget for training (if applicable).
  3461  // forceTrain - whether to force train even if dataset and configuration does not change (default: false).
  3462  // notificationEmailAddress - the email address to send notification to when training finishes (default: null).
  3463  func (client BaseClient) TrainProject(ctx context.Context, projectID uuid.UUID, trainingType string, reservedBudgetInHours *int32, forceTrain *bool, notificationEmailAddress string) (result Iteration, err error) {
  3464  	if tracing.IsEnabled() {
  3465  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.TrainProject")
  3466  		defer func() {
  3467  			sc := -1
  3468  			if result.Response.Response != nil {
  3469  				sc = result.Response.Response.StatusCode
  3470  			}
  3471  			tracing.EndSpan(ctx, sc, err)
  3472  		}()
  3473  	}
  3474  	req, err := client.TrainProjectPreparer(ctx, projectID, trainingType, reservedBudgetInHours, forceTrain, notificationEmailAddress)
  3475  	if err != nil {
  3476  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", nil, "Failure preparing request")
  3477  		return
  3478  	}
  3479  
  3480  	resp, err := client.TrainProjectSender(req)
  3481  	if err != nil {
  3482  		result.Response = autorest.Response{Response: resp}
  3483  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", resp, "Failure sending request")
  3484  		return
  3485  	}
  3486  
  3487  	result, err = client.TrainProjectResponder(resp)
  3488  	if err != nil {
  3489  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", resp, "Failure responding to request")
  3490  		return
  3491  	}
  3492  
  3493  	return
  3494  }
  3495  
  3496  // TrainProjectPreparer prepares the TrainProject request.
  3497  func (client BaseClient) TrainProjectPreparer(ctx context.Context, projectID uuid.UUID, trainingType string, reservedBudgetInHours *int32, forceTrain *bool, notificationEmailAddress string) (*http.Request, error) {
  3498  	urlParameters := map[string]interface{}{
  3499  		"Endpoint": client.Endpoint,
  3500  	}
  3501  
  3502  	pathParameters := map[string]interface{}{
  3503  		"projectId": autorest.Encode("path", projectID),
  3504  	}
  3505  
  3506  	queryParameters := map[string]interface{}{}
  3507  	if len(string(trainingType)) > 0 {
  3508  		queryParameters["trainingType"] = autorest.Encode("query", trainingType)
  3509  	}
  3510  	if reservedBudgetInHours != nil {
  3511  		queryParameters["reservedBudgetInHours"] = autorest.Encode("query", *reservedBudgetInHours)
  3512  	} else {
  3513  		queryParameters["reservedBudgetInHours"] = autorest.Encode("query", 0)
  3514  	}
  3515  	if forceTrain != nil {
  3516  		queryParameters["forceTrain"] = autorest.Encode("query", *forceTrain)
  3517  	} else {
  3518  		queryParameters["forceTrain"] = autorest.Encode("query", false)
  3519  	}
  3520  	if len(notificationEmailAddress) > 0 {
  3521  		queryParameters["notificationEmailAddress"] = autorest.Encode("query", notificationEmailAddress)
  3522  	}
  3523  
  3524  	preparer := autorest.CreatePreparer(
  3525  		autorest.AsPost(),
  3526  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3527  		autorest.WithPathParameters("/projects/{projectId}/train", pathParameters),
  3528  		autorest.WithQueryParameters(queryParameters),
  3529  		autorest.WithHeader("Training-Key", client.APIKey))
  3530  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3531  }
  3532  
  3533  // TrainProjectSender sends the TrainProject request. The method will close the
  3534  // http.Response Body if it receives an error.
  3535  func (client BaseClient) TrainProjectSender(req *http.Request) (*http.Response, error) {
  3536  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3537  }
  3538  
  3539  // TrainProjectResponder handles the response to the TrainProject request. The method always
  3540  // closes the http.Response Body.
  3541  func (client BaseClient) TrainProjectResponder(resp *http.Response) (result Iteration, err error) {
  3542  	err = autorest.Respond(
  3543  		resp,
  3544  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3545  		autorest.ByUnmarshallingJSON(&result),
  3546  		autorest.ByClosing())
  3547  	result.Response = autorest.Response{Response: resp}
  3548  	return
  3549  }
  3550  
  3551  // UnpublishIteration sends the unpublish iteration request.
  3552  // Parameters:
  3553  // projectID - the project id.
  3554  // iterationID - the iteration id.
  3555  func (client BaseClient) UnpublishIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result autorest.Response, err error) {
  3556  	if tracing.IsEnabled() {
  3557  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UnpublishIteration")
  3558  		defer func() {
  3559  			sc := -1
  3560  			if result.Response != nil {
  3561  				sc = result.Response.StatusCode
  3562  			}
  3563  			tracing.EndSpan(ctx, sc, err)
  3564  		}()
  3565  	}
  3566  	req, err := client.UnpublishIterationPreparer(ctx, projectID, iterationID)
  3567  	if err != nil {
  3568  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UnpublishIteration", nil, "Failure preparing request")
  3569  		return
  3570  	}
  3571  
  3572  	resp, err := client.UnpublishIterationSender(req)
  3573  	if err != nil {
  3574  		result.Response = resp
  3575  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UnpublishIteration", resp, "Failure sending request")
  3576  		return
  3577  	}
  3578  
  3579  	result, err = client.UnpublishIterationResponder(resp)
  3580  	if err != nil {
  3581  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UnpublishIteration", resp, "Failure responding to request")
  3582  		return
  3583  	}
  3584  
  3585  	return
  3586  }
  3587  
  3588  // UnpublishIterationPreparer prepares the UnpublishIteration request.
  3589  func (client BaseClient) UnpublishIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  3590  	urlParameters := map[string]interface{}{
  3591  		"Endpoint": client.Endpoint,
  3592  	}
  3593  
  3594  	pathParameters := map[string]interface{}{
  3595  		"iterationId": autorest.Encode("path", iterationID),
  3596  		"projectId":   autorest.Encode("path", projectID),
  3597  	}
  3598  
  3599  	preparer := autorest.CreatePreparer(
  3600  		autorest.AsDelete(),
  3601  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3602  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/publish", pathParameters),
  3603  		autorest.WithHeader("Training-Key", client.APIKey))
  3604  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3605  }
  3606  
  3607  // UnpublishIterationSender sends the UnpublishIteration request. The method will close the
  3608  // http.Response Body if it receives an error.
  3609  func (client BaseClient) UnpublishIterationSender(req *http.Request) (*http.Response, error) {
  3610  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3611  }
  3612  
  3613  // UnpublishIterationResponder handles the response to the UnpublishIteration request. The method always
  3614  // closes the http.Response Body.
  3615  func (client BaseClient) UnpublishIterationResponder(resp *http.Response) (result autorest.Response, err error) {
  3616  	err = autorest.Respond(
  3617  		resp,
  3618  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  3619  		autorest.ByClosing())
  3620  	result.Response = resp
  3621  	return
  3622  }
  3623  
  3624  // UpdateIteration sends the update iteration request.
  3625  // Parameters:
  3626  // projectID - project id.
  3627  // iterationID - iteration id.
  3628  // updatedIteration - the updated iteration model.
  3629  func (client BaseClient) UpdateIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, updatedIteration Iteration) (result Iteration, err error) {
  3630  	if tracing.IsEnabled() {
  3631  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateIteration")
  3632  		defer func() {
  3633  			sc := -1
  3634  			if result.Response.Response != nil {
  3635  				sc = result.Response.Response.StatusCode
  3636  			}
  3637  			tracing.EndSpan(ctx, sc, err)
  3638  		}()
  3639  	}
  3640  	req, err := client.UpdateIterationPreparer(ctx, projectID, iterationID, updatedIteration)
  3641  	if err != nil {
  3642  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", nil, "Failure preparing request")
  3643  		return
  3644  	}
  3645  
  3646  	resp, err := client.UpdateIterationSender(req)
  3647  	if err != nil {
  3648  		result.Response = autorest.Response{Response: resp}
  3649  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", resp, "Failure sending request")
  3650  		return
  3651  	}
  3652  
  3653  	result, err = client.UpdateIterationResponder(resp)
  3654  	if err != nil {
  3655  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", resp, "Failure responding to request")
  3656  		return
  3657  	}
  3658  
  3659  	return
  3660  }
  3661  
  3662  // UpdateIterationPreparer prepares the UpdateIteration request.
  3663  func (client BaseClient) UpdateIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, updatedIteration Iteration) (*http.Request, error) {
  3664  	urlParameters := map[string]interface{}{
  3665  		"Endpoint": client.Endpoint,
  3666  	}
  3667  
  3668  	pathParameters := map[string]interface{}{
  3669  		"iterationId": autorest.Encode("path", iterationID),
  3670  		"projectId":   autorest.Encode("path", projectID),
  3671  	}
  3672  
  3673  	updatedIteration.ID = nil
  3674  	updatedIteration.Status = nil
  3675  	updatedIteration.Created = nil
  3676  	updatedIteration.LastModified = nil
  3677  	updatedIteration.TrainedAt = nil
  3678  	updatedIteration.ProjectID = nil
  3679  	updatedIteration.Exportable = nil
  3680  	updatedIteration.ExportableTo = nil
  3681  	updatedIteration.DomainID = nil
  3682  	updatedIteration.ClassificationType = ""
  3683  	updatedIteration.TrainingType = ""
  3684  	updatedIteration.ReservedBudgetInHours = nil
  3685  	updatedIteration.TrainingTimeInMinutes = nil
  3686  	updatedIteration.PublishName = nil
  3687  	updatedIteration.OriginalPublishResourceID = nil
  3688  	preparer := autorest.CreatePreparer(
  3689  		autorest.AsContentType("application/json; charset=utf-8"),
  3690  		autorest.AsPatch(),
  3691  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3692  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
  3693  		autorest.WithJSON(updatedIteration),
  3694  		autorest.WithHeader("Training-Key", client.APIKey))
  3695  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3696  }
  3697  
  3698  // UpdateIterationSender sends the UpdateIteration request. The method will close the
  3699  // http.Response Body if it receives an error.
  3700  func (client BaseClient) UpdateIterationSender(req *http.Request) (*http.Response, error) {
  3701  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3702  }
  3703  
  3704  // UpdateIterationResponder handles the response to the UpdateIteration request. The method always
  3705  // closes the http.Response Body.
  3706  func (client BaseClient) UpdateIterationResponder(resp *http.Response) (result Iteration, err error) {
  3707  	err = autorest.Respond(
  3708  		resp,
  3709  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3710  		autorest.ByUnmarshallingJSON(&result),
  3711  		autorest.ByClosing())
  3712  	result.Response = autorest.Response{Response: resp}
  3713  	return
  3714  }
  3715  
  3716  // UpdateProject sends the update project request.
  3717  // Parameters:
  3718  // projectID - the id of the project to update.
  3719  // updatedProject - the updated project model.
  3720  func (client BaseClient) UpdateProject(ctx context.Context, projectID uuid.UUID, updatedProject Project) (result Project, err error) {
  3721  	if tracing.IsEnabled() {
  3722  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateProject")
  3723  		defer func() {
  3724  			sc := -1
  3725  			if result.Response.Response != nil {
  3726  				sc = result.Response.Response.StatusCode
  3727  			}
  3728  			tracing.EndSpan(ctx, sc, err)
  3729  		}()
  3730  	}
  3731  	req, err := client.UpdateProjectPreparer(ctx, projectID, updatedProject)
  3732  	if err != nil {
  3733  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", nil, "Failure preparing request")
  3734  		return
  3735  	}
  3736  
  3737  	resp, err := client.UpdateProjectSender(req)
  3738  	if err != nil {
  3739  		result.Response = autorest.Response{Response: resp}
  3740  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", resp, "Failure sending request")
  3741  		return
  3742  	}
  3743  
  3744  	result, err = client.UpdateProjectResponder(resp)
  3745  	if err != nil {
  3746  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", resp, "Failure responding to request")
  3747  		return
  3748  	}
  3749  
  3750  	return
  3751  }
  3752  
  3753  // UpdateProjectPreparer prepares the UpdateProject request.
  3754  func (client BaseClient) UpdateProjectPreparer(ctx context.Context, projectID uuid.UUID, updatedProject Project) (*http.Request, error) {
  3755  	urlParameters := map[string]interface{}{
  3756  		"Endpoint": client.Endpoint,
  3757  	}
  3758  
  3759  	pathParameters := map[string]interface{}{
  3760  		"projectId": autorest.Encode("path", projectID),
  3761  	}
  3762  
  3763  	updatedProject.ID = nil
  3764  	updatedProject.Created = nil
  3765  	updatedProject.LastModified = nil
  3766  	updatedProject.ThumbnailURI = nil
  3767  	updatedProject.DrModeEnabled = nil
  3768  	preparer := autorest.CreatePreparer(
  3769  		autorest.AsContentType("application/json; charset=utf-8"),
  3770  		autorest.AsPatch(),
  3771  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3772  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  3773  		autorest.WithJSON(updatedProject),
  3774  		autorest.WithHeader("Training-Key", client.APIKey))
  3775  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3776  }
  3777  
  3778  // UpdateProjectSender sends the UpdateProject request. The method will close the
  3779  // http.Response Body if it receives an error.
  3780  func (client BaseClient) UpdateProjectSender(req *http.Request) (*http.Response, error) {
  3781  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3782  }
  3783  
  3784  // UpdateProjectResponder handles the response to the UpdateProject request. The method always
  3785  // closes the http.Response Body.
  3786  func (client BaseClient) UpdateProjectResponder(resp *http.Response) (result Project, err error) {
  3787  	err = autorest.Respond(
  3788  		resp,
  3789  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3790  		autorest.ByUnmarshallingJSON(&result),
  3791  		autorest.ByClosing())
  3792  	result.Response = autorest.Response{Response: resp}
  3793  	return
  3794  }
  3795  
  3796  // UpdateTag sends the update tag request.
  3797  // Parameters:
  3798  // projectID - the project id.
  3799  // tagID - the id of the target tag.
  3800  // updatedTag - the updated tag model.
  3801  func (client BaseClient) UpdateTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, updatedTag Tag) (result Tag, err error) {
  3802  	if tracing.IsEnabled() {
  3803  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateTag")
  3804  		defer func() {
  3805  			sc := -1
  3806  			if result.Response.Response != nil {
  3807  				sc = result.Response.Response.StatusCode
  3808  			}
  3809  			tracing.EndSpan(ctx, sc, err)
  3810  		}()
  3811  	}
  3812  	req, err := client.UpdateTagPreparer(ctx, projectID, tagID, updatedTag)
  3813  	if err != nil {
  3814  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", nil, "Failure preparing request")
  3815  		return
  3816  	}
  3817  
  3818  	resp, err := client.UpdateTagSender(req)
  3819  	if err != nil {
  3820  		result.Response = autorest.Response{Response: resp}
  3821  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", resp, "Failure sending request")
  3822  		return
  3823  	}
  3824  
  3825  	result, err = client.UpdateTagResponder(resp)
  3826  	if err != nil {
  3827  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", resp, "Failure responding to request")
  3828  		return
  3829  	}
  3830  
  3831  	return
  3832  }
  3833  
  3834  // UpdateTagPreparer prepares the UpdateTag request.
  3835  func (client BaseClient) UpdateTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, updatedTag Tag) (*http.Request, error) {
  3836  	urlParameters := map[string]interface{}{
  3837  		"Endpoint": client.Endpoint,
  3838  	}
  3839  
  3840  	pathParameters := map[string]interface{}{
  3841  		"projectId": autorest.Encode("path", projectID),
  3842  		"tagId":     autorest.Encode("path", tagID),
  3843  	}
  3844  
  3845  	updatedTag.ID = nil
  3846  	updatedTag.ImageCount = nil
  3847  	preparer := autorest.CreatePreparer(
  3848  		autorest.AsContentType("application/json; charset=utf-8"),
  3849  		autorest.AsPatch(),
  3850  		autorest.WithCustomBaseURL("{Endpoint}/customvision/v3.1/training", urlParameters),
  3851  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  3852  		autorest.WithJSON(updatedTag),
  3853  		autorest.WithHeader("Training-Key", client.APIKey))
  3854  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3855  }
  3856  
  3857  // UpdateTagSender sends the UpdateTag request. The method will close the
  3858  // http.Response Body if it receives an error.
  3859  func (client BaseClient) UpdateTagSender(req *http.Request) (*http.Response, error) {
  3860  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3861  }
  3862  
  3863  // UpdateTagResponder handles the response to the UpdateTag request. The method always
  3864  // closes the http.Response Body.
  3865  func (client BaseClient) UpdateTagResponder(resp *http.Response) (result Tag, err error) {
  3866  	err = autorest.Respond(
  3867  		resp,
  3868  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3869  		autorest.ByUnmarshallingJSON(&result),
  3870  		autorest.ByClosing())
  3871  	result.Response = autorest.Response{Response: resp}
  3872  	return
  3873  }
  3874  

View as plain text