github.com/spinnaker/spin@v1.30.0/gateapi/api_pipeline_controller.go (about)

     1  
     2  /*
     3   * Spinnaker API
     4   *
     5   * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
     6   *
     7   * API version: 1.0.0
     8   * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)
     9   */
    10  
    11  package swagger
    12  
    13  import (
    14  	"context"
    15  	"io/ioutil"
    16  	"net/http"
    17  	"net/url"
    18  	"strings"
    19  	"fmt"
    20  	"github.com/antihax/optional"
    21  )
    22  
    23  // Linger please
    24  var (
    25  	_ context.Context
    26  )
    27  
    28  type PipelineControllerApiService service
    29  
    30  /* 
    31  PipelineControllerApiService Cancel a pipeline execution
    32   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
    33   * @param id id
    34   * @param optional nil or *PipelineControllerApiCancelPipelineUsingPUT1Opts - Optional Parameters:
    35       * @param "Force" (optional.Bool) -  force
    36       * @param "Reason" (optional.String) -  reason
    37  
    38  
    39  */
    40  
    41  type PipelineControllerApiCancelPipelineUsingPUT1Opts struct { 
    42  	Force optional.Bool
    43  	Reason optional.String
    44  }
    45  
    46  func (a *PipelineControllerApiService) CancelPipelineUsingPUT1(ctx context.Context, id string, localVarOptionals *PipelineControllerApiCancelPipelineUsingPUT1Opts) (*http.Response, error) {
    47  	var (
    48  		localVarHttpMethod = strings.ToUpper("Put")
    49  		localVarPostBody   interface{}
    50  		localVarFileName   string
    51  		localVarFileBytes  []byte
    52  		
    53  	)
    54  
    55  	// create path and map variables
    56  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/cancel"
    57  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
    58  
    59  	localVarHeaderParams := make(map[string]string)
    60  	localVarQueryParams := url.Values{}
    61  	localVarFormParams := url.Values{}
    62  
    63  	if localVarOptionals != nil && localVarOptionals.Force.IsSet() {
    64  		localVarQueryParams.Add("force", parameterToString(localVarOptionals.Force.Value(), ""))
    65  	}
    66  	if localVarOptionals != nil && localVarOptionals.Reason.IsSet() {
    67  		localVarQueryParams.Add("reason", parameterToString(localVarOptionals.Reason.Value(), ""))
    68  	}
    69  	// to determine the Content-Type header
    70  	localVarHttpContentTypes := []string{"application/json"}
    71  
    72  	// set Content-Type header
    73  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
    74  	if localVarHttpContentType != "" {
    75  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
    76  	}
    77  
    78  	// to determine the Accept header
    79  	localVarHttpHeaderAccepts := []string{"*/*"}
    80  
    81  	// set Accept header
    82  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
    83  	if localVarHttpHeaderAccept != "" {
    84  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
    85  	}
    86  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
    87  	if err != nil {
    88  		return nil, err
    89  	}
    90  
    91  	localVarHttpResponse, err := a.client.callAPI(r)
    92  	if err != nil || localVarHttpResponse == nil {
    93  		return localVarHttpResponse, err
    94  	}
    95  
    96  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
    97  	localVarHttpResponse.Body.Close()
    98  	if err != nil {
    99  		return localVarHttpResponse, err
   100  	}
   101  
   102  
   103  	if localVarHttpResponse.StatusCode >= 300 {
   104  		newErr := GenericSwaggerError{
   105  			body: localVarBody,
   106  			error: localVarHttpResponse.Status,
   107  		}
   108  		
   109  		return localVarHttpResponse, newErr
   110  	}
   111  
   112  	return localVarHttpResponse, nil
   113  }
   114  
   115  /* 
   116  PipelineControllerApiService Delete a pipeline definition
   117   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   118   * @param application application
   119   * @param pipelineName pipelineName
   120  
   121  
   122  */
   123  func (a *PipelineControllerApiService) DeletePipelineUsingDELETE(ctx context.Context, application string, pipelineName string) (*http.Response, error) {
   124  	var (
   125  		localVarHttpMethod = strings.ToUpper("Delete")
   126  		localVarPostBody   interface{}
   127  		localVarFileName   string
   128  		localVarFileBytes  []byte
   129  		
   130  	)
   131  
   132  	// create path and map variables
   133  	localVarPath := a.client.cfg.BasePath + "/pipelines/{application}/{pipelineName}"
   134  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   135  	localVarPath = strings.Replace(localVarPath, "{"+"pipelineName"+"}", fmt.Sprintf("%v", pipelineName), -1)
   136  
   137  	localVarHeaderParams := make(map[string]string)
   138  	localVarQueryParams := url.Values{}
   139  	localVarFormParams := url.Values{}
   140  
   141  	// to determine the Content-Type header
   142  	localVarHttpContentTypes := []string{}
   143  
   144  	// set Content-Type header
   145  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   146  	if localVarHttpContentType != "" {
   147  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   148  	}
   149  
   150  	// to determine the Accept header
   151  	localVarHttpHeaderAccepts := []string{"*/*"}
   152  
   153  	// set Accept header
   154  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   155  	if localVarHttpHeaderAccept != "" {
   156  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   157  	}
   158  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   159  	if err != nil {
   160  		return nil, err
   161  	}
   162  
   163  	localVarHttpResponse, err := a.client.callAPI(r)
   164  	if err != nil || localVarHttpResponse == nil {
   165  		return localVarHttpResponse, err
   166  	}
   167  
   168  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   169  	localVarHttpResponse.Body.Close()
   170  	if err != nil {
   171  		return localVarHttpResponse, err
   172  	}
   173  
   174  
   175  	if localVarHttpResponse.StatusCode >= 300 {
   176  		newErr := GenericSwaggerError{
   177  			body: localVarBody,
   178  			error: localVarHttpResponse.Status,
   179  		}
   180  		
   181  		return localVarHttpResponse, newErr
   182  	}
   183  
   184  	return localVarHttpResponse, nil
   185  }
   186  
   187  /* 
   188  PipelineControllerApiService Delete a pipeline execution
   189   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   190   * @param id id
   191  
   192  @return map[string]interface{}
   193  */
   194  func (a *PipelineControllerApiService) DeletePipelineUsingDELETE1(ctx context.Context, id string) (map[string]interface{}, *http.Response, error) {
   195  	var (
   196  		localVarHttpMethod = strings.ToUpper("Delete")
   197  		localVarPostBody   interface{}
   198  		localVarFileName   string
   199  		localVarFileBytes  []byte
   200  		localVarReturnValue map[string]interface{}
   201  	)
   202  
   203  	// create path and map variables
   204  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}"
   205  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
   206  
   207  	localVarHeaderParams := make(map[string]string)
   208  	localVarQueryParams := url.Values{}
   209  	localVarFormParams := url.Values{}
   210  
   211  	// to determine the Content-Type header
   212  	localVarHttpContentTypes := []string{}
   213  
   214  	// set Content-Type header
   215  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   216  	if localVarHttpContentType != "" {
   217  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   218  	}
   219  
   220  	// to determine the Accept header
   221  	localVarHttpHeaderAccepts := []string{"*/*"}
   222  
   223  	// set Accept header
   224  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   225  	if localVarHttpHeaderAccept != "" {
   226  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   227  	}
   228  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   229  	if err != nil {
   230  		return localVarReturnValue, nil, err
   231  	}
   232  
   233  	localVarHttpResponse, err := a.client.callAPI(r)
   234  	if err != nil || localVarHttpResponse == nil {
   235  		return localVarReturnValue, localVarHttpResponse, err
   236  	}
   237  
   238  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   239  	localVarHttpResponse.Body.Close()
   240  	if err != nil {
   241  		return localVarReturnValue, localVarHttpResponse, err
   242  	}
   243  
   244  	if localVarHttpResponse.StatusCode < 300 {
   245  		// If we succeed, return the data, otherwise pass on to decode error.
   246  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   247  		if err == nil { 
   248  			return localVarReturnValue, localVarHttpResponse, err
   249  		}
   250  	}
   251  
   252  	if localVarHttpResponse.StatusCode >= 300 {
   253  		newErr := GenericSwaggerError{
   254  			body: localVarBody,
   255  			error: localVarHttpResponse.Status,
   256  		}
   257  		
   258  		if localVarHttpResponse.StatusCode == 200 {
   259  			var v map[string]interface{}
   260  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   261  				if err != nil {
   262  					newErr.error = err.Error()
   263  					return localVarReturnValue, localVarHttpResponse, newErr
   264  				}
   265  				newErr.model = v
   266  				return localVarReturnValue, localVarHttpResponse, newErr
   267  		}
   268  		
   269  		return localVarReturnValue, localVarHttpResponse, newErr
   270  	}
   271  
   272  	return localVarReturnValue, localVarHttpResponse, nil
   273  }
   274  
   275  /* 
   276  PipelineControllerApiService Evaluate a pipeline expression at a specific stage using the provided execution as context
   277   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   278   * @param expression expression
   279   * @param id id
   280   * @param stageId stageId
   281  
   282  @return map[string]interface{}
   283  */
   284  func (a *PipelineControllerApiService) EvaluateExpressionForExecutionAtStageUsingGET(ctx context.Context, expression string, id string, stageId string) (map[string]interface{}, *http.Response, error) {
   285  	var (
   286  		localVarHttpMethod = strings.ToUpper("Get")
   287  		localVarPostBody   interface{}
   288  		localVarFileName   string
   289  		localVarFileBytes  []byte
   290  		localVarReturnValue map[string]interface{}
   291  	)
   292  
   293  	// create path and map variables
   294  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/{stageId}/evaluateExpression"
   295  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
   296  	localVarPath = strings.Replace(localVarPath, "{"+"stageId"+"}", fmt.Sprintf("%v", stageId), -1)
   297  
   298  	localVarHeaderParams := make(map[string]string)
   299  	localVarQueryParams := url.Values{}
   300  	localVarFormParams := url.Values{}
   301  
   302  	localVarQueryParams.Add("expression", parameterToString(expression, ""))
   303  	// to determine the Content-Type header
   304  	localVarHttpContentTypes := []string{}
   305  
   306  	// set Content-Type header
   307  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   308  	if localVarHttpContentType != "" {
   309  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   310  	}
   311  
   312  	// to determine the Accept header
   313  	localVarHttpHeaderAccepts := []string{"*/*"}
   314  
   315  	// set Accept header
   316  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   317  	if localVarHttpHeaderAccept != "" {
   318  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   319  	}
   320  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   321  	if err != nil {
   322  		return localVarReturnValue, nil, err
   323  	}
   324  
   325  	localVarHttpResponse, err := a.client.callAPI(r)
   326  	if err != nil || localVarHttpResponse == nil {
   327  		return localVarReturnValue, localVarHttpResponse, err
   328  	}
   329  
   330  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   331  	localVarHttpResponse.Body.Close()
   332  	if err != nil {
   333  		return localVarReturnValue, localVarHttpResponse, err
   334  	}
   335  
   336  	if localVarHttpResponse.StatusCode < 300 {
   337  		// If we succeed, return the data, otherwise pass on to decode error.
   338  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   339  		if err == nil { 
   340  			return localVarReturnValue, localVarHttpResponse, err
   341  		}
   342  	}
   343  
   344  	if localVarHttpResponse.StatusCode >= 300 {
   345  		newErr := GenericSwaggerError{
   346  			body: localVarBody,
   347  			error: localVarHttpResponse.Status,
   348  		}
   349  		
   350  		if localVarHttpResponse.StatusCode == 200 {
   351  			var v map[string]interface{}
   352  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   353  				if err != nil {
   354  					newErr.error = err.Error()
   355  					return localVarReturnValue, localVarHttpResponse, newErr
   356  				}
   357  				newErr.model = v
   358  				return localVarReturnValue, localVarHttpResponse, newErr
   359  		}
   360  		
   361  		return localVarReturnValue, localVarHttpResponse, newErr
   362  	}
   363  
   364  	return localVarReturnValue, localVarHttpResponse, nil
   365  }
   366  
   367  /* 
   368  PipelineControllerApiService Evaluate a pipeline expression using the provided execution as context
   369   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   370   * @param expression expression
   371   * @param id id
   372  
   373  @return map[string]interface{}
   374  */
   375  func (a *PipelineControllerApiService) EvaluateExpressionForExecutionUsingGET(ctx context.Context, expression string, id string) (map[string]interface{}, *http.Response, error) {
   376  	var (
   377  		localVarHttpMethod = strings.ToUpper("Get")
   378  		localVarPostBody   interface{}
   379  		localVarFileName   string
   380  		localVarFileBytes  []byte
   381  		localVarReturnValue map[string]interface{}
   382  	)
   383  
   384  	// create path and map variables
   385  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/evaluateExpression"
   386  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
   387  
   388  	localVarHeaderParams := make(map[string]string)
   389  	localVarQueryParams := url.Values{}
   390  	localVarFormParams := url.Values{}
   391  
   392  	localVarQueryParams.Add("expression", parameterToString(expression, ""))
   393  	// to determine the Content-Type header
   394  	localVarHttpContentTypes := []string{}
   395  
   396  	// set Content-Type header
   397  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   398  	if localVarHttpContentType != "" {
   399  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   400  	}
   401  
   402  	// to determine the Accept header
   403  	localVarHttpHeaderAccepts := []string{"*/*"}
   404  
   405  	// set Accept header
   406  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   407  	if localVarHttpHeaderAccept != "" {
   408  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   409  	}
   410  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   411  	if err != nil {
   412  		return localVarReturnValue, nil, err
   413  	}
   414  
   415  	localVarHttpResponse, err := a.client.callAPI(r)
   416  	if err != nil || localVarHttpResponse == nil {
   417  		return localVarReturnValue, localVarHttpResponse, err
   418  	}
   419  
   420  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   421  	localVarHttpResponse.Body.Close()
   422  	if err != nil {
   423  		return localVarReturnValue, localVarHttpResponse, err
   424  	}
   425  
   426  	if localVarHttpResponse.StatusCode < 300 {
   427  		// If we succeed, return the data, otherwise pass on to decode error.
   428  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   429  		if err == nil { 
   430  			return localVarReturnValue, localVarHttpResponse, err
   431  		}
   432  	}
   433  
   434  	if localVarHttpResponse.StatusCode >= 300 {
   435  		newErr := GenericSwaggerError{
   436  			body: localVarBody,
   437  			error: localVarHttpResponse.Status,
   438  		}
   439  		
   440  		if localVarHttpResponse.StatusCode == 200 {
   441  			var v map[string]interface{}
   442  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   443  				if err != nil {
   444  					newErr.error = err.Error()
   445  					return localVarReturnValue, localVarHttpResponse, newErr
   446  				}
   447  				newErr.model = v
   448  				return localVarReturnValue, localVarHttpResponse, newErr
   449  		}
   450  		
   451  		return localVarReturnValue, localVarHttpResponse, newErr
   452  	}
   453  
   454  	return localVarReturnValue, localVarHttpResponse, nil
   455  }
   456  
   457  /* 
   458  PipelineControllerApiService Evaluate a pipeline expression using the provided execution as context
   459   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   460   * @param id id
   461   * @param pipelineExpression pipelineExpression
   462  
   463  @return map[string]interface{}
   464  */
   465  func (a *PipelineControllerApiService) EvaluateExpressionForExecutionViaPOSTUsingPOST1(ctx context.Context, id string, pipelineExpression interface{}) (map[string]interface{}, *http.Response, error) {
   466  	var (
   467  		localVarHttpMethod = strings.ToUpper("Post")
   468  		localVarPostBody   interface{}
   469  		localVarFileName   string
   470  		localVarFileBytes  []byte
   471  		localVarReturnValue map[string]interface{}
   472  	)
   473  
   474  	// create path and map variables
   475  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/evaluateExpression"
   476  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
   477  
   478  	localVarHeaderParams := make(map[string]string)
   479  	localVarQueryParams := url.Values{}
   480  	localVarFormParams := url.Values{}
   481  
   482  	// to determine the Content-Type header
   483  	localVarHttpContentTypes := []string{"application/json"}
   484  
   485  	// set Content-Type header
   486  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   487  	if localVarHttpContentType != "" {
   488  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   489  	}
   490  
   491  	// to determine the Accept header
   492  	localVarHttpHeaderAccepts := []string{"*/*"}
   493  
   494  	// set Accept header
   495  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   496  	if localVarHttpHeaderAccept != "" {
   497  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   498  	}
   499  	// body params
   500  	localVarPostBody = &pipelineExpression
   501  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   502  	if err != nil {
   503  		return localVarReturnValue, nil, err
   504  	}
   505  
   506  	localVarHttpResponse, err := a.client.callAPI(r)
   507  	if err != nil || localVarHttpResponse == nil {
   508  		return localVarReturnValue, localVarHttpResponse, err
   509  	}
   510  
   511  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   512  	localVarHttpResponse.Body.Close()
   513  	if err != nil {
   514  		return localVarReturnValue, localVarHttpResponse, err
   515  	}
   516  
   517  	if localVarHttpResponse.StatusCode < 300 {
   518  		// If we succeed, return the data, otherwise pass on to decode error.
   519  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   520  		if err == nil { 
   521  			return localVarReturnValue, localVarHttpResponse, err
   522  		}
   523  	}
   524  
   525  	if localVarHttpResponse.StatusCode >= 300 {
   526  		newErr := GenericSwaggerError{
   527  			body: localVarBody,
   528  			error: localVarHttpResponse.Status,
   529  		}
   530  		
   531  		if localVarHttpResponse.StatusCode == 200 {
   532  			var v map[string]interface{}
   533  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   534  				if err != nil {
   535  					newErr.error = err.Error()
   536  					return localVarReturnValue, localVarHttpResponse, newErr
   537  				}
   538  				newErr.model = v
   539  				return localVarReturnValue, localVarHttpResponse, newErr
   540  		}
   541  		
   542  		return localVarReturnValue, localVarHttpResponse, newErr
   543  	}
   544  
   545  	return localVarReturnValue, localVarHttpResponse, nil
   546  }
   547  
   548  /* 
   549  PipelineControllerApiService Evaluate variables same as Evaluate Variables stage using the provided execution as context
   550   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   551   * @param executionId Execution id to run against
   552   * @param expressions List of variables/expressions to evaluate
   553   * @param optional nil or *PipelineControllerApiEvaluateVariablesUsingPOSTOpts - Optional Parameters:
   554       * @param "RequisiteStageRefIds" (optional.String) -  Comma separated list of requisite stage IDs for the evaluation stage
   555       * @param "SpelVersion" (optional.String) -  Version of SpEL evaluation logic to use (v3 or v4)
   556  
   557  @return map[string]interface{}
   558  */
   559  
   560  type PipelineControllerApiEvaluateVariablesUsingPOSTOpts struct { 
   561  	RequisiteStageRefIds optional.String
   562  	SpelVersion optional.String
   563  }
   564  
   565  func (a *PipelineControllerApiService) EvaluateVariablesUsingPOST(ctx context.Context, executionId string, expressions []Mapstringstring, localVarOptionals *PipelineControllerApiEvaluateVariablesUsingPOSTOpts) (map[string]interface{}, *http.Response, error) {
   566  	var (
   567  		localVarHttpMethod = strings.ToUpper("Post")
   568  		localVarPostBody   interface{}
   569  		localVarFileName   string
   570  		localVarFileBytes  []byte
   571  		localVarReturnValue map[string]interface{}
   572  	)
   573  
   574  	// create path and map variables
   575  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/evaluateVariables"
   576  
   577  	localVarHeaderParams := make(map[string]string)
   578  	localVarQueryParams := url.Values{}
   579  	localVarFormParams := url.Values{}
   580  
   581  	localVarQueryParams.Add("executionId", parameterToString(executionId, ""))
   582  	if localVarOptionals != nil && localVarOptionals.RequisiteStageRefIds.IsSet() {
   583  		localVarQueryParams.Add("requisiteStageRefIds", parameterToString(localVarOptionals.RequisiteStageRefIds.Value(), ""))
   584  	}
   585  	if localVarOptionals != nil && localVarOptionals.SpelVersion.IsSet() {
   586  		localVarQueryParams.Add("spelVersion", parameterToString(localVarOptionals.SpelVersion.Value(), ""))
   587  	}
   588  	// to determine the Content-Type header
   589  	localVarHttpContentTypes := []string{"application/json"}
   590  
   591  	// set Content-Type header
   592  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   593  	if localVarHttpContentType != "" {
   594  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   595  	}
   596  
   597  	// to determine the Accept header
   598  	localVarHttpHeaderAccepts := []string{"*/*"}
   599  
   600  	// set Accept header
   601  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   602  	if localVarHttpHeaderAccept != "" {
   603  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   604  	}
   605  	// body params
   606  	localVarPostBody = &expressions
   607  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   608  	if err != nil {
   609  		return localVarReturnValue, nil, err
   610  	}
   611  
   612  	localVarHttpResponse, err := a.client.callAPI(r)
   613  	if err != nil || localVarHttpResponse == nil {
   614  		return localVarReturnValue, localVarHttpResponse, err
   615  	}
   616  
   617  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   618  	localVarHttpResponse.Body.Close()
   619  	if err != nil {
   620  		return localVarReturnValue, localVarHttpResponse, err
   621  	}
   622  
   623  	if localVarHttpResponse.StatusCode < 300 {
   624  		// If we succeed, return the data, otherwise pass on to decode error.
   625  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   626  		if err == nil { 
   627  			return localVarReturnValue, localVarHttpResponse, err
   628  		}
   629  	}
   630  
   631  	if localVarHttpResponse.StatusCode >= 300 {
   632  		newErr := GenericSwaggerError{
   633  			body: localVarBody,
   634  			error: localVarHttpResponse.Status,
   635  		}
   636  		
   637  		if localVarHttpResponse.StatusCode == 200 {
   638  			var v map[string]interface{}
   639  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   640  				if err != nil {
   641  					newErr.error = err.Error()
   642  					return localVarReturnValue, localVarHttpResponse, newErr
   643  				}
   644  				newErr.model = v
   645  				return localVarReturnValue, localVarHttpResponse, newErr
   646  		}
   647  		
   648  		return localVarReturnValue, localVarHttpResponse, newErr
   649  	}
   650  
   651  	return localVarReturnValue, localVarHttpResponse, nil
   652  }
   653  
   654  /* 
   655  PipelineControllerApiService Retrieve a pipeline execution
   656   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   657   * @param id id
   658  
   659  @return interface{}
   660  */
   661  func (a *PipelineControllerApiService) GetPipelineUsingGET(ctx context.Context, id string) (interface{}, *http.Response, error) {
   662  	var (
   663  		localVarHttpMethod = strings.ToUpper("Get")
   664  		localVarPostBody   interface{}
   665  		localVarFileName   string
   666  		localVarFileBytes  []byte
   667  		localVarReturnValue interface{}
   668  	)
   669  
   670  	// create path and map variables
   671  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}"
   672  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
   673  
   674  	localVarHeaderParams := make(map[string]string)
   675  	localVarQueryParams := url.Values{}
   676  	localVarFormParams := url.Values{}
   677  
   678  	// to determine the Content-Type header
   679  	localVarHttpContentTypes := []string{}
   680  
   681  	// set Content-Type header
   682  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   683  	if localVarHttpContentType != "" {
   684  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   685  	}
   686  
   687  	// to determine the Accept header
   688  	localVarHttpHeaderAccepts := []string{"*/*"}
   689  
   690  	// set Accept header
   691  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   692  	if localVarHttpHeaderAccept != "" {
   693  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   694  	}
   695  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   696  	if err != nil {
   697  		return localVarReturnValue, nil, err
   698  	}
   699  
   700  	localVarHttpResponse, err := a.client.callAPI(r)
   701  	if err != nil || localVarHttpResponse == nil {
   702  		return localVarReturnValue, localVarHttpResponse, err
   703  	}
   704  
   705  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   706  	localVarHttpResponse.Body.Close()
   707  	if err != nil {
   708  		return localVarReturnValue, localVarHttpResponse, err
   709  	}
   710  
   711  	if localVarHttpResponse.StatusCode < 300 {
   712  		// If we succeed, return the data, otherwise pass on to decode error.
   713  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   714  		if err == nil { 
   715  			return localVarReturnValue, localVarHttpResponse, err
   716  		}
   717  	}
   718  
   719  	if localVarHttpResponse.StatusCode >= 300 {
   720  		newErr := GenericSwaggerError{
   721  			body: localVarBody,
   722  			error: localVarHttpResponse.Status,
   723  		}
   724  		
   725  		if localVarHttpResponse.StatusCode == 200 {
   726  			var v interface{}
   727  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   728  				if err != nil {
   729  					newErr.error = err.Error()
   730  					return localVarReturnValue, localVarHttpResponse, newErr
   731  				}
   732  				newErr.model = v
   733  				return localVarReturnValue, localVarHttpResponse, newErr
   734  		}
   735  		
   736  		return localVarReturnValue, localVarHttpResponse, newErr
   737  	}
   738  
   739  	return localVarReturnValue, localVarHttpResponse, nil
   740  }
   741  
   742  /* 
   743  PipelineControllerApiService Trigger a pipeline execution
   744   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   745   * @param application application
   746   * @param pipelineNameOrId pipelineNameOrId
   747   * @param optional nil or *PipelineControllerApiInvokePipelineConfigUsingPOST1Opts - Optional Parameters:
   748       * @param "Trigger" (optional.Interface of interface{}) -  trigger
   749  
   750  
   751  */
   752  
   753  type PipelineControllerApiInvokePipelineConfigUsingPOST1Opts struct { 
   754  	Trigger optional.Interface
   755  }
   756  
   757  func (a *PipelineControllerApiService) InvokePipelineConfigUsingPOST1(ctx context.Context, application string, pipelineNameOrId string, localVarOptionals *PipelineControllerApiInvokePipelineConfigUsingPOST1Opts) (*http.Response, error) {
   758  	var (
   759  		localVarHttpMethod = strings.ToUpper("Post")
   760  		localVarPostBody   interface{}
   761  		localVarFileName   string
   762  		localVarFileBytes  []byte
   763  		
   764  	)
   765  
   766  	// create path and map variables
   767  	localVarPath := a.client.cfg.BasePath + "/pipelines/{application}/{pipelineNameOrId}"
   768  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   769  	localVarPath = strings.Replace(localVarPath, "{"+"pipelineNameOrId"+"}", fmt.Sprintf("%v", pipelineNameOrId), -1)
   770  
   771  	localVarHeaderParams := make(map[string]string)
   772  	localVarQueryParams := url.Values{}
   773  	localVarFormParams := url.Values{}
   774  
   775  	// to determine the Content-Type header
   776  	localVarHttpContentTypes := []string{"application/json"}
   777  
   778  	// set Content-Type header
   779  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   780  	if localVarHttpContentType != "" {
   781  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   782  	}
   783  
   784  	// to determine the Accept header
   785  	localVarHttpHeaderAccepts := []string{"*/*"}
   786  
   787  	// set Accept header
   788  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   789  	if localVarHttpHeaderAccept != "" {
   790  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   791  	}
   792  	// body params
   793  	if localVarOptionals != nil && localVarOptionals.Trigger.IsSet() {
   794  		
   795  		localVarOptionalTrigger, localVarOptionalTriggerok := localVarOptionals.Trigger.Value().(interface{})
   796  		if !localVarOptionalTriggerok {
   797  				return nil, reportError("trigger should be interface{}")
   798  		}
   799  		localVarPostBody = &localVarOptionalTrigger
   800  	}
   801  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   802  	if err != nil {
   803  		return nil, err
   804  	}
   805  
   806  	localVarHttpResponse, err := a.client.callAPI(r)
   807  	if err != nil || localVarHttpResponse == nil {
   808  		return localVarHttpResponse, err
   809  	}
   810  
   811  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   812  	localVarHttpResponse.Body.Close()
   813  	if err != nil {
   814  		return localVarHttpResponse, err
   815  	}
   816  
   817  
   818  	if localVarHttpResponse.StatusCode >= 300 {
   819  		newErr := GenericSwaggerError{
   820  			body: localVarBody,
   821  			error: localVarHttpResponse.Status,
   822  		}
   823  		
   824  		if localVarHttpResponse.StatusCode == 202 {
   825  			var v interface{}
   826  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   827  				if err != nil {
   828  					newErr.error = err.Error()
   829  					return localVarHttpResponse, newErr
   830  				}
   831  				newErr.model = v
   832  				return localVarHttpResponse, newErr
   833  		}
   834  		
   835  		return localVarHttpResponse, newErr
   836  	}
   837  
   838  	return localVarHttpResponse, nil
   839  }
   840  
   841  /* 
   842  PipelineControllerApiService Trigger a pipeline execution
   843   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   844   * @param application application
   845   * @param pipelineNameOrId pipelineNameOrId
   846   * @param optional nil or *PipelineControllerApiInvokePipelineConfigViaEchoUsingPOSTOpts - Optional Parameters:
   847       * @param "Trigger" (optional.Interface of interface{}) -  trigger
   848  
   849  @return interface{}
   850  */
   851  
   852  type PipelineControllerApiInvokePipelineConfigViaEchoUsingPOSTOpts struct { 
   853  	Trigger optional.Interface
   854  }
   855  
   856  func (a *PipelineControllerApiService) InvokePipelineConfigViaEchoUsingPOST(ctx context.Context, application string, pipelineNameOrId string, localVarOptionals *PipelineControllerApiInvokePipelineConfigViaEchoUsingPOSTOpts) (interface{}, *http.Response, error) {
   857  	var (
   858  		localVarHttpMethod = strings.ToUpper("Post")
   859  		localVarPostBody   interface{}
   860  		localVarFileName   string
   861  		localVarFileBytes  []byte
   862  		localVarReturnValue interface{}
   863  	)
   864  
   865  	// create path and map variables
   866  	localVarPath := a.client.cfg.BasePath + "/pipelines/v2/{application}/{pipelineNameOrId}"
   867  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   868  	localVarPath = strings.Replace(localVarPath, "{"+"pipelineNameOrId"+"}", fmt.Sprintf("%v", pipelineNameOrId), -1)
   869  
   870  	localVarHeaderParams := make(map[string]string)
   871  	localVarQueryParams := url.Values{}
   872  	localVarFormParams := url.Values{}
   873  
   874  	// to determine the Content-Type header
   875  	localVarHttpContentTypes := []string{"application/json"}
   876  
   877  	// set Content-Type header
   878  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   879  	if localVarHttpContentType != "" {
   880  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   881  	}
   882  
   883  	// to determine the Accept header
   884  	localVarHttpHeaderAccepts := []string{"*/*"}
   885  
   886  	// set Accept header
   887  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   888  	if localVarHttpHeaderAccept != "" {
   889  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   890  	}
   891  	// body params
   892  	if localVarOptionals != nil && localVarOptionals.Trigger.IsSet() {
   893  		
   894  		localVarOptionalTrigger, localVarOptionalTriggerok := localVarOptionals.Trigger.Value().(interface{})
   895  		if !localVarOptionalTriggerok {
   896  				return localVarReturnValue, nil, reportError("trigger should be interface{}")
   897  		}
   898  		localVarPostBody = &localVarOptionalTrigger
   899  	}
   900  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   901  	if err != nil {
   902  		return localVarReturnValue, nil, err
   903  	}
   904  
   905  	localVarHttpResponse, err := a.client.callAPI(r)
   906  	if err != nil || localVarHttpResponse == nil {
   907  		return localVarReturnValue, localVarHttpResponse, err
   908  	}
   909  
   910  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   911  	localVarHttpResponse.Body.Close()
   912  	if err != nil {
   913  		return localVarReturnValue, localVarHttpResponse, err
   914  	}
   915  
   916  	if localVarHttpResponse.StatusCode < 300 {
   917  		// If we succeed, return the data, otherwise pass on to decode error.
   918  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   919  		if err == nil { 
   920  			return localVarReturnValue, localVarHttpResponse, err
   921  		}
   922  	}
   923  
   924  	if localVarHttpResponse.StatusCode >= 300 {
   925  		newErr := GenericSwaggerError{
   926  			body: localVarBody,
   927  			error: localVarHttpResponse.Status,
   928  		}
   929  		
   930  		if localVarHttpResponse.StatusCode == 200 {
   931  			var v interface{}
   932  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   933  				if err != nil {
   934  					newErr.error = err.Error()
   935  					return localVarReturnValue, localVarHttpResponse, newErr
   936  				}
   937  				newErr.model = v
   938  				return localVarReturnValue, localVarHttpResponse, newErr
   939  		}
   940  		
   941  		return localVarReturnValue, localVarHttpResponse, newErr
   942  	}
   943  
   944  	return localVarReturnValue, localVarHttpResponse, nil
   945  }
   946  
   947  /* 
   948  PipelineControllerApiService Pause a pipeline execution
   949   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   950   * @param id id
   951  
   952  
   953  */
   954  func (a *PipelineControllerApiService) PausePipelineUsingPUT(ctx context.Context, id string) (*http.Response, error) {
   955  	var (
   956  		localVarHttpMethod = strings.ToUpper("Put")
   957  		localVarPostBody   interface{}
   958  		localVarFileName   string
   959  		localVarFileBytes  []byte
   960  		
   961  	)
   962  
   963  	// create path and map variables
   964  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/pause"
   965  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
   966  
   967  	localVarHeaderParams := make(map[string]string)
   968  	localVarQueryParams := url.Values{}
   969  	localVarFormParams := url.Values{}
   970  
   971  	// to determine the Content-Type header
   972  	localVarHttpContentTypes := []string{"application/json"}
   973  
   974  	// set Content-Type header
   975  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   976  	if localVarHttpContentType != "" {
   977  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   978  	}
   979  
   980  	// to determine the Accept header
   981  	localVarHttpHeaderAccepts := []string{"*/*"}
   982  
   983  	// set Accept header
   984  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   985  	if localVarHttpHeaderAccept != "" {
   986  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   987  	}
   988  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   989  	if err != nil {
   990  		return nil, err
   991  	}
   992  
   993  	localVarHttpResponse, err := a.client.callAPI(r)
   994  	if err != nil || localVarHttpResponse == nil {
   995  		return localVarHttpResponse, err
   996  	}
   997  
   998  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   999  	localVarHttpResponse.Body.Close()
  1000  	if err != nil {
  1001  		return localVarHttpResponse, err
  1002  	}
  1003  
  1004  
  1005  	if localVarHttpResponse.StatusCode >= 300 {
  1006  		newErr := GenericSwaggerError{
  1007  			body: localVarBody,
  1008  			error: localVarHttpResponse.Status,
  1009  		}
  1010  		
  1011  		return localVarHttpResponse, newErr
  1012  	}
  1013  
  1014  	return localVarHttpResponse, nil
  1015  }
  1016  
  1017  /* 
  1018  PipelineControllerApiService Rename a pipeline definition
  1019   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1020   * @param renameCommand renameCommand
  1021  
  1022  
  1023  */
  1024  func (a *PipelineControllerApiService) RenamePipelineUsingPOST(ctx context.Context, renameCommand interface{}) (*http.Response, error) {
  1025  	var (
  1026  		localVarHttpMethod = strings.ToUpper("Post")
  1027  		localVarPostBody   interface{}
  1028  		localVarFileName   string
  1029  		localVarFileBytes  []byte
  1030  		
  1031  	)
  1032  
  1033  	// create path and map variables
  1034  	localVarPath := a.client.cfg.BasePath + "/pipelines/move"
  1035  
  1036  	localVarHeaderParams := make(map[string]string)
  1037  	localVarQueryParams := url.Values{}
  1038  	localVarFormParams := url.Values{}
  1039  
  1040  	// to determine the Content-Type header
  1041  	localVarHttpContentTypes := []string{"application/json"}
  1042  
  1043  	// set Content-Type header
  1044  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1045  	if localVarHttpContentType != "" {
  1046  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1047  	}
  1048  
  1049  	// to determine the Accept header
  1050  	localVarHttpHeaderAccepts := []string{"*/*"}
  1051  
  1052  	// set Accept header
  1053  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1054  	if localVarHttpHeaderAccept != "" {
  1055  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1056  	}
  1057  	// body params
  1058  	localVarPostBody = &renameCommand
  1059  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1060  	if err != nil {
  1061  		return nil, err
  1062  	}
  1063  
  1064  	localVarHttpResponse, err := a.client.callAPI(r)
  1065  	if err != nil || localVarHttpResponse == nil {
  1066  		return localVarHttpResponse, err
  1067  	}
  1068  
  1069  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1070  	localVarHttpResponse.Body.Close()
  1071  	if err != nil {
  1072  		return localVarHttpResponse, err
  1073  	}
  1074  
  1075  
  1076  	if localVarHttpResponse.StatusCode >= 300 {
  1077  		newErr := GenericSwaggerError{
  1078  			body: localVarBody,
  1079  			error: localVarHttpResponse.Status,
  1080  		}
  1081  		
  1082  		return localVarHttpResponse, newErr
  1083  	}
  1084  
  1085  	return localVarHttpResponse, nil
  1086  }
  1087  
  1088  /* 
  1089  PipelineControllerApiService Restart a stage execution
  1090   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1091   * @param context context
  1092   * @param id id
  1093   * @param stageId stageId
  1094  
  1095  @return map[string]interface{}
  1096  */
  1097  func (a *PipelineControllerApiService) RestartStageUsingPUT(ctx context.Context, context interface{}, id string, stageId string) (map[string]interface{}, *http.Response, error) {
  1098  	var (
  1099  		localVarHttpMethod = strings.ToUpper("Put")
  1100  		localVarPostBody   interface{}
  1101  		localVarFileName   string
  1102  		localVarFileBytes  []byte
  1103  		localVarReturnValue map[string]interface{}
  1104  	)
  1105  
  1106  	// create path and map variables
  1107  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/stages/{stageId}/restart"
  1108  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
  1109  	localVarPath = strings.Replace(localVarPath, "{"+"stageId"+"}", fmt.Sprintf("%v", stageId), -1)
  1110  
  1111  	localVarHeaderParams := make(map[string]string)
  1112  	localVarQueryParams := url.Values{}
  1113  	localVarFormParams := url.Values{}
  1114  
  1115  	// to determine the Content-Type header
  1116  	localVarHttpContentTypes := []string{"application/json"}
  1117  
  1118  	// set Content-Type header
  1119  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1120  	if localVarHttpContentType != "" {
  1121  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1122  	}
  1123  
  1124  	// to determine the Accept header
  1125  	localVarHttpHeaderAccepts := []string{"*/*"}
  1126  
  1127  	// set Accept header
  1128  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1129  	if localVarHttpHeaderAccept != "" {
  1130  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1131  	}
  1132  	// body params
  1133  	localVarPostBody = &context
  1134  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1135  	if err != nil {
  1136  		return localVarReturnValue, nil, err
  1137  	}
  1138  
  1139  	localVarHttpResponse, err := a.client.callAPI(r)
  1140  	if err != nil || localVarHttpResponse == nil {
  1141  		return localVarReturnValue, localVarHttpResponse, err
  1142  	}
  1143  
  1144  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1145  	localVarHttpResponse.Body.Close()
  1146  	if err != nil {
  1147  		return localVarReturnValue, localVarHttpResponse, err
  1148  	}
  1149  
  1150  	if localVarHttpResponse.StatusCode < 300 {
  1151  		// If we succeed, return the data, otherwise pass on to decode error.
  1152  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1153  		if err == nil { 
  1154  			return localVarReturnValue, localVarHttpResponse, err
  1155  		}
  1156  	}
  1157  
  1158  	if localVarHttpResponse.StatusCode >= 300 {
  1159  		newErr := GenericSwaggerError{
  1160  			body: localVarBody,
  1161  			error: localVarHttpResponse.Status,
  1162  		}
  1163  		
  1164  		if localVarHttpResponse.StatusCode == 200 {
  1165  			var v map[string]interface{}
  1166  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1167  				if err != nil {
  1168  					newErr.error = err.Error()
  1169  					return localVarReturnValue, localVarHttpResponse, newErr
  1170  				}
  1171  				newErr.model = v
  1172  				return localVarReturnValue, localVarHttpResponse, newErr
  1173  		}
  1174  		
  1175  		return localVarReturnValue, localVarHttpResponse, newErr
  1176  	}
  1177  
  1178  	return localVarReturnValue, localVarHttpResponse, nil
  1179  }
  1180  
  1181  /* 
  1182  PipelineControllerApiService Resume a pipeline execution
  1183   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1184   * @param id id
  1185  
  1186  @return map[string]interface{}
  1187  */
  1188  func (a *PipelineControllerApiService) ResumePipelineUsingPUT(ctx context.Context, id string) (map[string]interface{}, *http.Response, error) {
  1189  	var (
  1190  		localVarHttpMethod = strings.ToUpper("Put")
  1191  		localVarPostBody   interface{}
  1192  		localVarFileName   string
  1193  		localVarFileBytes  []byte
  1194  		localVarReturnValue map[string]interface{}
  1195  	)
  1196  
  1197  	// create path and map variables
  1198  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/resume"
  1199  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
  1200  
  1201  	localVarHeaderParams := make(map[string]string)
  1202  	localVarQueryParams := url.Values{}
  1203  	localVarFormParams := url.Values{}
  1204  
  1205  	// to determine the Content-Type header
  1206  	localVarHttpContentTypes := []string{"application/json"}
  1207  
  1208  	// set Content-Type header
  1209  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1210  	if localVarHttpContentType != "" {
  1211  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1212  	}
  1213  
  1214  	// to determine the Accept header
  1215  	localVarHttpHeaderAccepts := []string{"*/*"}
  1216  
  1217  	// set Accept header
  1218  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1219  	if localVarHttpHeaderAccept != "" {
  1220  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1221  	}
  1222  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1223  	if err != nil {
  1224  		return localVarReturnValue, nil, err
  1225  	}
  1226  
  1227  	localVarHttpResponse, err := a.client.callAPI(r)
  1228  	if err != nil || localVarHttpResponse == nil {
  1229  		return localVarReturnValue, localVarHttpResponse, err
  1230  	}
  1231  
  1232  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1233  	localVarHttpResponse.Body.Close()
  1234  	if err != nil {
  1235  		return localVarReturnValue, localVarHttpResponse, err
  1236  	}
  1237  
  1238  	if localVarHttpResponse.StatusCode < 300 {
  1239  		// If we succeed, return the data, otherwise pass on to decode error.
  1240  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1241  		if err == nil { 
  1242  			return localVarReturnValue, localVarHttpResponse, err
  1243  		}
  1244  	}
  1245  
  1246  	if localVarHttpResponse.StatusCode >= 300 {
  1247  		newErr := GenericSwaggerError{
  1248  			body: localVarBody,
  1249  			error: localVarHttpResponse.Status,
  1250  		}
  1251  		
  1252  		if localVarHttpResponse.StatusCode == 200 {
  1253  			var v map[string]interface{}
  1254  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1255  				if err != nil {
  1256  					newErr.error = err.Error()
  1257  					return localVarReturnValue, localVarHttpResponse, newErr
  1258  				}
  1259  				newErr.model = v
  1260  				return localVarReturnValue, localVarHttpResponse, newErr
  1261  		}
  1262  		
  1263  		return localVarReturnValue, localVarHttpResponse, newErr
  1264  	}
  1265  
  1266  	return localVarReturnValue, localVarHttpResponse, nil
  1267  }
  1268  
  1269  /* 
  1270  PipelineControllerApiService Save a pipeline definition
  1271   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1272   * @param pipeline pipeline
  1273   * @param optional nil or *PipelineControllerApiSavePipelineUsingPOSTOpts - Optional Parameters:
  1274       * @param "StaleCheck" (optional.Bool) -  staleCheck
  1275  
  1276  
  1277  */
  1278  
  1279  type PipelineControllerApiSavePipelineUsingPOSTOpts struct { 
  1280  	StaleCheck optional.Bool
  1281  }
  1282  
  1283  func (a *PipelineControllerApiService) SavePipelineUsingPOST(ctx context.Context, pipeline interface{}, localVarOptionals *PipelineControllerApiSavePipelineUsingPOSTOpts) (*http.Response, error) {
  1284  	var (
  1285  		localVarHttpMethod = strings.ToUpper("Post")
  1286  		localVarPostBody   interface{}
  1287  		localVarFileName   string
  1288  		localVarFileBytes  []byte
  1289  		
  1290  	)
  1291  
  1292  	// create path and map variables
  1293  	localVarPath := a.client.cfg.BasePath + "/pipelines"
  1294  
  1295  	localVarHeaderParams := make(map[string]string)
  1296  	localVarQueryParams := url.Values{}
  1297  	localVarFormParams := url.Values{}
  1298  
  1299  	if localVarOptionals != nil && localVarOptionals.StaleCheck.IsSet() {
  1300  		localVarQueryParams.Add("staleCheck", parameterToString(localVarOptionals.StaleCheck.Value(), ""))
  1301  	}
  1302  	// to determine the Content-Type header
  1303  	localVarHttpContentTypes := []string{"application/json"}
  1304  
  1305  	// set Content-Type header
  1306  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1307  	if localVarHttpContentType != "" {
  1308  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1309  	}
  1310  
  1311  	// to determine the Accept header
  1312  	localVarHttpHeaderAccepts := []string{"*/*"}
  1313  
  1314  	// set Accept header
  1315  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1316  	if localVarHttpHeaderAccept != "" {
  1317  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1318  	}
  1319  	// body params
  1320  	localVarPostBody = &pipeline
  1321  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1322  	if err != nil {
  1323  		return nil, err
  1324  	}
  1325  
  1326  	localVarHttpResponse, err := a.client.callAPI(r)
  1327  	if err != nil || localVarHttpResponse == nil {
  1328  		return localVarHttpResponse, err
  1329  	}
  1330  
  1331  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1332  	localVarHttpResponse.Body.Close()
  1333  	if err != nil {
  1334  		return localVarHttpResponse, err
  1335  	}
  1336  
  1337  
  1338  	if localVarHttpResponse.StatusCode >= 300 {
  1339  		newErr := GenericSwaggerError{
  1340  			body: localVarBody,
  1341  			error: localVarHttpResponse.Status,
  1342  		}
  1343  		
  1344  		return localVarHttpResponse, newErr
  1345  	}
  1346  
  1347  	return localVarHttpResponse, nil
  1348  }
  1349  
  1350  /* 
  1351  PipelineControllerApiService Initiate a pipeline execution
  1352   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1353   * @param map_ map
  1354  
  1355  @return ResponseEntity
  1356  */
  1357  func (a *PipelineControllerApiService) StartUsingPOST(ctx context.Context, map_ interface{}) (ResponseEntity, *http.Response, error) {
  1358  	var (
  1359  		localVarHttpMethod = strings.ToUpper("Post")
  1360  		localVarPostBody   interface{}
  1361  		localVarFileName   string
  1362  		localVarFileBytes  []byte
  1363  		localVarReturnValue ResponseEntity
  1364  	)
  1365  
  1366  	// create path and map variables
  1367  	localVarPath := a.client.cfg.BasePath + "/pipelines/start"
  1368  
  1369  	localVarHeaderParams := make(map[string]string)
  1370  	localVarQueryParams := url.Values{}
  1371  	localVarFormParams := url.Values{}
  1372  
  1373  	// to determine the Content-Type header
  1374  	localVarHttpContentTypes := []string{"application/json"}
  1375  
  1376  	// set Content-Type header
  1377  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1378  	if localVarHttpContentType != "" {
  1379  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1380  	}
  1381  
  1382  	// to determine the Accept header
  1383  	localVarHttpHeaderAccepts := []string{"*/*"}
  1384  
  1385  	// set Accept header
  1386  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1387  	if localVarHttpHeaderAccept != "" {
  1388  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1389  	}
  1390  	// body params
  1391  	localVarPostBody = &map_
  1392  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1393  	if err != nil {
  1394  		return localVarReturnValue, nil, err
  1395  	}
  1396  
  1397  	localVarHttpResponse, err := a.client.callAPI(r)
  1398  	if err != nil || localVarHttpResponse == nil {
  1399  		return localVarReturnValue, localVarHttpResponse, err
  1400  	}
  1401  
  1402  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1403  	localVarHttpResponse.Body.Close()
  1404  	if err != nil {
  1405  		return localVarReturnValue, localVarHttpResponse, err
  1406  	}
  1407  
  1408  	if localVarHttpResponse.StatusCode < 300 {
  1409  		// If we succeed, return the data, otherwise pass on to decode error.
  1410  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1411  		if err == nil { 
  1412  			return localVarReturnValue, localVarHttpResponse, err
  1413  		}
  1414  	}
  1415  
  1416  	if localVarHttpResponse.StatusCode >= 300 {
  1417  		newErr := GenericSwaggerError{
  1418  			body: localVarBody,
  1419  			error: localVarHttpResponse.Status,
  1420  		}
  1421  		
  1422  		if localVarHttpResponse.StatusCode == 200 {
  1423  			var v ResponseEntity
  1424  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1425  				if err != nil {
  1426  					newErr.error = err.Error()
  1427  					return localVarReturnValue, localVarHttpResponse, newErr
  1428  				}
  1429  				newErr.model = v
  1430  				return localVarReturnValue, localVarHttpResponse, newErr
  1431  		}
  1432  		
  1433  		return localVarReturnValue, localVarHttpResponse, newErr
  1434  	}
  1435  
  1436  	return localVarReturnValue, localVarHttpResponse, nil
  1437  }
  1438  
  1439  /* 
  1440  PipelineControllerApiService Update a pipeline definition
  1441   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1442   * @param id id
  1443   * @param pipeline pipeline
  1444  
  1445  @return map[string]interface{}
  1446  */
  1447  func (a *PipelineControllerApiService) UpdatePipelineUsingPUT(ctx context.Context, id string, pipeline interface{}) (map[string]interface{}, *http.Response, error) {
  1448  	var (
  1449  		localVarHttpMethod = strings.ToUpper("Put")
  1450  		localVarPostBody   interface{}
  1451  		localVarFileName   string
  1452  		localVarFileBytes  []byte
  1453  		localVarReturnValue map[string]interface{}
  1454  	)
  1455  
  1456  	// create path and map variables
  1457  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}"
  1458  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
  1459  
  1460  	localVarHeaderParams := make(map[string]string)
  1461  	localVarQueryParams := url.Values{}
  1462  	localVarFormParams := url.Values{}
  1463  
  1464  	// to determine the Content-Type header
  1465  	localVarHttpContentTypes := []string{"application/json"}
  1466  
  1467  	// set Content-Type header
  1468  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1469  	if localVarHttpContentType != "" {
  1470  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1471  	}
  1472  
  1473  	// to determine the Accept header
  1474  	localVarHttpHeaderAccepts := []string{"*/*"}
  1475  
  1476  	// set Accept header
  1477  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1478  	if localVarHttpHeaderAccept != "" {
  1479  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1480  	}
  1481  	// body params
  1482  	localVarPostBody = &pipeline
  1483  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1484  	if err != nil {
  1485  		return localVarReturnValue, nil, err
  1486  	}
  1487  
  1488  	localVarHttpResponse, err := a.client.callAPI(r)
  1489  	if err != nil || localVarHttpResponse == nil {
  1490  		return localVarReturnValue, localVarHttpResponse, err
  1491  	}
  1492  
  1493  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1494  	localVarHttpResponse.Body.Close()
  1495  	if err != nil {
  1496  		return localVarReturnValue, localVarHttpResponse, err
  1497  	}
  1498  
  1499  	if localVarHttpResponse.StatusCode < 300 {
  1500  		// If we succeed, return the data, otherwise pass on to decode error.
  1501  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1502  		if err == nil { 
  1503  			return localVarReturnValue, localVarHttpResponse, err
  1504  		}
  1505  	}
  1506  
  1507  	if localVarHttpResponse.StatusCode >= 300 {
  1508  		newErr := GenericSwaggerError{
  1509  			body: localVarBody,
  1510  			error: localVarHttpResponse.Status,
  1511  		}
  1512  		
  1513  		if localVarHttpResponse.StatusCode == 200 {
  1514  			var v map[string]interface{}
  1515  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1516  				if err != nil {
  1517  					newErr.error = err.Error()
  1518  					return localVarReturnValue, localVarHttpResponse, newErr
  1519  				}
  1520  				newErr.model = v
  1521  				return localVarReturnValue, localVarHttpResponse, newErr
  1522  		}
  1523  		
  1524  		return localVarReturnValue, localVarHttpResponse, newErr
  1525  	}
  1526  
  1527  	return localVarReturnValue, localVarHttpResponse, nil
  1528  }
  1529  
  1530  /* 
  1531  PipelineControllerApiService Update a stage execution
  1532   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1533   * @param context context
  1534   * @param id id
  1535   * @param stageId stageId
  1536  
  1537  @return map[string]interface{}
  1538  */
  1539  func (a *PipelineControllerApiService) UpdateStageUsingPATCH(ctx context.Context, context interface{}, id string, stageId string) (map[string]interface{}, *http.Response, error) {
  1540  	var (
  1541  		localVarHttpMethod = strings.ToUpper("Patch")
  1542  		localVarPostBody   interface{}
  1543  		localVarFileName   string
  1544  		localVarFileBytes  []byte
  1545  		localVarReturnValue map[string]interface{}
  1546  	)
  1547  
  1548  	// create path and map variables
  1549  	localVarPath := a.client.cfg.BasePath + "/pipelines/{id}/stages/{stageId}"
  1550  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
  1551  	localVarPath = strings.Replace(localVarPath, "{"+"stageId"+"}", fmt.Sprintf("%v", stageId), -1)
  1552  
  1553  	localVarHeaderParams := make(map[string]string)
  1554  	localVarQueryParams := url.Values{}
  1555  	localVarFormParams := url.Values{}
  1556  
  1557  	// to determine the Content-Type header
  1558  	localVarHttpContentTypes := []string{"application/json"}
  1559  
  1560  	// set Content-Type header
  1561  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1562  	if localVarHttpContentType != "" {
  1563  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1564  	}
  1565  
  1566  	// to determine the Accept header
  1567  	localVarHttpHeaderAccepts := []string{"*/*"}
  1568  
  1569  	// set Accept header
  1570  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1571  	if localVarHttpHeaderAccept != "" {
  1572  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1573  	}
  1574  	// body params
  1575  	localVarPostBody = &context
  1576  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1577  	if err != nil {
  1578  		return localVarReturnValue, nil, err
  1579  	}
  1580  
  1581  	localVarHttpResponse, err := a.client.callAPI(r)
  1582  	if err != nil || localVarHttpResponse == nil {
  1583  		return localVarReturnValue, localVarHttpResponse, err
  1584  	}
  1585  
  1586  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1587  	localVarHttpResponse.Body.Close()
  1588  	if err != nil {
  1589  		return localVarReturnValue, localVarHttpResponse, err
  1590  	}
  1591  
  1592  	if localVarHttpResponse.StatusCode < 300 {
  1593  		// If we succeed, return the data, otherwise pass on to decode error.
  1594  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1595  		if err == nil { 
  1596  			return localVarReturnValue, localVarHttpResponse, err
  1597  		}
  1598  	}
  1599  
  1600  	if localVarHttpResponse.StatusCode >= 300 {
  1601  		newErr := GenericSwaggerError{
  1602  			body: localVarBody,
  1603  			error: localVarHttpResponse.Status,
  1604  		}
  1605  		
  1606  		if localVarHttpResponse.StatusCode == 200 {
  1607  			var v map[string]interface{}
  1608  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1609  				if err != nil {
  1610  					newErr.error = err.Error()
  1611  					return localVarReturnValue, localVarHttpResponse, newErr
  1612  				}
  1613  				newErr.model = v
  1614  				return localVarReturnValue, localVarHttpResponse, newErr
  1615  		}
  1616  		
  1617  		return localVarReturnValue, localVarHttpResponse, newErr
  1618  	}
  1619  
  1620  	return localVarReturnValue, localVarHttpResponse, nil
  1621  }