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

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

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

View as plain text