\TemplateApi

All URIs are relative to http://localhost:5516

Method	HTTP request	Description
CopyTemplate	Post /api/v1/templates/{templateId}/copy
CreateTemplate	Post /api/v1/templates
CreateTemplate1	Post /api/v1/templates/{templateId}/create
CreateTemplateVariable	Post /api/v1/templates/{templateId}/variables
DeleteTemplate	Delete /api/v1/templates/{templateId}
DeleteTemplateVariable	Delete /api/v1/templates/{variableId}
ExportTemplateToZip	Get /api/v1/templates/zip/{templateId}
GetPossibleTemplateVariableValues	Get /api/v1/templates/{variableId}/possibleValues
GetTemplate	Get /api/v1/templates/{templateId}
GetTemplatePermissions	Get /api/v1/templates/permissions
GetTemplateTeams	Get /api/v1/templates/{templateId}/teams
GetTemplateVariable	Get /api/v1/templates/{variableId}
GetTemplateVariables	Get /api/v1/templates/{templateId}/variables
GetTemplates	Get /api/v1/templates
ImportTemplate	Post /api/v1/templates/import
IsVariableUsedTemplate	Get /api/v1/templates/{variableId}/used
ReplaceTemplateVariables	Post /api/v1/templates/{variableId}/replace
SetTemplateTeams	Post /api/v1/templates/{templateId}/teams
StartTemplate	Post /api/v1/templates/{templateId}/start
UpdateTemplate	Put /api/v1/templates/{templateId}
UpdateTemplateVariable	Put /api/v1/templates/{variableId}
UpdateTemplateVariables	Put /api/v1/templates/{releaseId}/variables

CopyTemplate

Release CopyTemplate(ctx, templateId).CopyTemplate(copyTemplate).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 
    copyTemplate := *openapiclient.NewCopyTemplate() // CopyTemplate |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.CopyTemplate(context.Background(), templateId).CopyTemplate(copyTemplate).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.CopyTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CopyTemplate`: Release
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.CopyTemplate`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiCopyTemplateRequest struct via the builder pattern

Name	Type	Description	Notes

copyTemplate | CopyTemplate | |

Return type

Release

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

CreateTemplate

Release CreateTemplate(ctx).FolderId(folderId).Release(release).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    folderId := "folderId_example" // string |  (optional)
    release := *openapiclient.NewRelease() // Release |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.CreateTemplate(context.Background()).FolderId(folderId).Release(release).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.CreateTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateTemplate`: Release
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.CreateTemplate`: %v\n", resp)
}

Path Parameters

Other Parameters

Other parameters are passed through a pointer to a apiCreateTemplateRequest struct via the builder pattern

Name	Type	Description	Notes
folderId	string
release	Release

Return type

Release

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

CreateTemplate1

Release CreateTemplate1(ctx, templateId).CreateRelease(createRelease).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 
    createRelease := *openapiclient.NewCreateRelease() // CreateRelease |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.CreateTemplate1(context.Background(), templateId).CreateRelease(createRelease).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.CreateTemplate1``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateTemplate1`: Release
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.CreateTemplate1`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiCreateTemplate1Request struct via the builder pattern

Name	Type	Description	Notes

createRelease | CreateRelease | |

Return type

Release

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

CreateTemplateVariable

Variable CreateTemplateVariable(ctx, templateId).Variable1(variable1).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 
    variable1 := *openapiclient.NewVariable1() // Variable1 |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.CreateTemplateVariable(context.Background(), templateId).Variable1(variable1).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.CreateTemplateVariable``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateTemplateVariable`: Variable
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.CreateTemplateVariable`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiCreateTemplateVariableRequest struct via the builder pattern

Name	Type	Description	Notes

variable1 | Variable1 | |

Return type

Variable

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteTemplate

DeleteTemplate(ctx, templateId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    r, err := apiClient.TemplateApi.DeleteTemplate(context.Background(), templateId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.DeleteTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteTemplateRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

(empty response body)

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: Not defined

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteTemplateVariable

DeleteTemplateVariable(ctx, variableId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    variableId := "variableId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    r, err := apiClient.TemplateApi.DeleteTemplateVariable(context.Background(), variableId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.DeleteTemplateVariable``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
variableId	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteTemplateVariableRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

(empty response body)

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: Not defined

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ExportTemplateToZip

ExportTemplateToZip(ctx, templateId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    r, err := apiClient.TemplateApi.ExportTemplateToZip(context.Background(), templateId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.ExportTemplateToZip``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiExportTemplateToZipRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

(empty response body)

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: Not defined

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetPossibleTemplateVariableValues

[]map[string]interface{} GetPossibleTemplateVariableValues(ctx, variableId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    variableId := "variableId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.GetPossibleTemplateVariableValues(context.Background(), variableId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.GetPossibleTemplateVariableValues``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetPossibleTemplateVariableValues`: []map[string]interface{}
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.GetPossibleTemplateVariableValues`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
variableId	string

Other Parameters

Other parameters are passed through a pointer to a apiGetPossibleTemplateVariableValuesRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]map[string]interface{}

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetTemplate

Release GetTemplate(ctx, templateId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.GetTemplate(context.Background(), templateId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.GetTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetTemplate`: Release
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.GetTemplate`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiGetTemplateRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

Release

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetTemplatePermissions

[]string GetTemplatePermissions(ctx).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.GetTemplatePermissions(context.Background()).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.GetTemplatePermissions``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetTemplatePermissions`: []string
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.GetTemplatePermissions`: %v\n", resp)
}

Path Parameters

This endpoint does not need any parameter.

Other Parameters

Other parameters are passed through a pointer to a apiGetTemplatePermissionsRequest struct via the builder pattern

Return type

[]string

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetTemplateTeams

[]TeamView GetTemplateTeams(ctx, templateId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.GetTemplateTeams(context.Background(), templateId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.GetTemplateTeams``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetTemplateTeams`: []TeamView
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.GetTemplateTeams`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiGetTemplateTeamsRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]TeamView

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetTemplateVariable

Variable GetTemplateVariable(ctx, variableId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    variableId := "variableId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.GetTemplateVariable(context.Background(), variableId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.GetTemplateVariable``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetTemplateVariable`: Variable
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.GetTemplateVariable`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
variableId	string

Other Parameters

Other parameters are passed through a pointer to a apiGetTemplateVariableRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

Variable

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetTemplateVariables

[]Variable GetTemplateVariables(ctx, templateId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.GetTemplateVariables(context.Background(), templateId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.GetTemplateVariables``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetTemplateVariables`: []Variable
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.GetTemplateVariables`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiGetTemplateVariablesRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]Variable

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetTemplates

[]Release GetTemplates(ctx).Depth(depth).Page(page).ResultsPerPage(resultsPerPage).Tag(tag).Title(title).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    depth := int32(56) // int32 |  (optional) (default to 1)
    page := int64(789) // int64 |  (optional) (default to 0)
    resultsPerPage := int64(789) // int64 |  (optional) (default to 100)
    tag := []string{"Inner_example"} // []string |  (optional)
    title := "title_example" // string |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.GetTemplates(context.Background()).Depth(depth).Page(page).ResultsPerPage(resultsPerPage).Tag(tag).Title(title).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.GetTemplates``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetTemplates`: []Release
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.GetTemplates`: %v\n", resp)
}

Path Parameters

Other Parameters

Other parameters are passed through a pointer to a apiGetTemplatesRequest struct via the builder pattern

Name	Type	Notes
depth	int32	[default to 1]
page	int64	[default to 0]
resultsPerPage	int64	[default to 100]
tag	[]string
title	string

Return type

[]Release

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ImportTemplate

[]ImportResult ImportTemplate(ctx).FolderId(folderId).Version(version).Body(body).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    folderId := "folderId_example" // string |  (optional)
    version := "version_example" // string |  (optional)
    body := "body_example" // string |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.ImportTemplate(context.Background()).FolderId(folderId).Version(version).Body(body).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.ImportTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ImportTemplate`: []ImportResult
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.ImportTemplate`: %v\n", resp)
}

Path Parameters

Other Parameters

Other parameters are passed through a pointer to a apiImportTemplateRequest struct via the builder pattern

Name	Type	Description	Notes
folderId	string
version	string
body	string

Return type

[]ImportResult

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

IsVariableUsedTemplate

bool IsVariableUsedTemplate(ctx, variableId).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    variableId := "variableId_example" // string | 

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.IsVariableUsedTemplate(context.Background(), variableId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.IsVariableUsedTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `IsVariableUsedTemplate`: bool
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.IsVariableUsedTemplate`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
variableId	string

Other Parameters

Other parameters are passed through a pointer to a apiIsVariableUsedTemplateRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

bool

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ReplaceTemplateVariables

ReplaceTemplateVariables(ctx, variableId).VariableOrValue(variableOrValue).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    variableId := "variableId_example" // string | 
    variableOrValue := *openapiclient.NewVariableOrValue() // VariableOrValue |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    r, err := apiClient.TemplateApi.ReplaceTemplateVariables(context.Background(), variableId).VariableOrValue(variableOrValue).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.ReplaceTemplateVariables``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
variableId	string

Other Parameters

Other parameters are passed through a pointer to a apiReplaceTemplateVariablesRequest struct via the builder pattern

Name	Type	Description	Notes

variableOrValue | VariableOrValue | |

Return type

(empty response body)

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: Not defined

[Back to top] [Back to API list] [Back to Model list] [Back to README]

SetTemplateTeams

[]TeamView SetTemplateTeams(ctx, templateId).TeamView(teamView).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 
    teamView := []openapiclient.TeamView{*openapiclient.NewTeamView()} // []TeamView |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.SetTemplateTeams(context.Background(), templateId).TeamView(teamView).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.SetTemplateTeams``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `SetTemplateTeams`: []TeamView
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.SetTemplateTeams`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiSetTemplateTeamsRequest struct via the builder pattern

Name	Type	Description	Notes

teamView | []TeamView | |

Return type

[]TeamView

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

StartTemplate

Release StartTemplate(ctx, templateId).StartRelease(startRelease).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 
    startRelease := *openapiclient.NewStartRelease() // StartRelease |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.StartTemplate(context.Background(), templateId).StartRelease(startRelease).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.StartTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `StartTemplate`: Release
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.StartTemplate`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiStartTemplateRequest struct via the builder pattern

Name	Type	Description	Notes

startRelease | StartRelease | |

Return type

Release

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

UpdateTemplate

Release UpdateTemplate(ctx, templateId).Release(release).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    templateId := "templateId_example" // string | 
    release := *openapiclient.NewRelease() // Release |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.UpdateTemplate(context.Background(), templateId).Release(release).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.UpdateTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateTemplate`: Release
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.UpdateTemplate`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
templateId	string

Other Parameters

Other parameters are passed through a pointer to a apiUpdateTemplateRequest struct via the builder pattern

Name	Type	Description	Notes

release | Release | |

Return type

Release

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

UpdateTemplateVariable

Variable UpdateTemplateVariable(ctx, variableId).Variable(variable).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    variableId := "variableId_example" // string | 
    variable := *openapiclient.NewVariable() // Variable |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.UpdateTemplateVariable(context.Background(), variableId).Variable(variable).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.UpdateTemplateVariable``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateTemplateVariable`: Variable
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.UpdateTemplateVariable`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
variableId	string

Other Parameters

Other parameters are passed through a pointer to a apiUpdateTemplateVariableRequest struct via the builder pattern

Name	Type	Description	Notes

variable | Variable | |

Return type

Variable

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

UpdateTemplateVariables

[]Variable UpdateTemplateVariables(ctx, releaseId).Variable(variable).Execute()

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID"
)

func main() {
    releaseId := "releaseId_example" // string | 
    variable := []openapiclient.Variable{*openapiclient.NewVariable()} // []Variable |  (optional)

    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.TemplateApi.UpdateTemplateVariables(context.Background(), releaseId).Variable(variable).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `TemplateApi.UpdateTemplateVariables``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateTemplateVariables`: []Variable
    fmt.Fprintf(os.Stdout, "Response from `TemplateApi.UpdateTemplateVariables`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
releaseId	string

Other Parameters

Other parameters are passed through a pointer to a apiUpdateTemplateVariablesRequest struct via the builder pattern

Name	Type	Description	Notes

variable | []Variable | |

Return type

[]Variable

Authorization

basicAuth, patAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

Files

TemplateApi.md

Latest commit

History

TemplateApi.md

File metadata and controls

\TemplateApi

CopyTemplate

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

CreateTemplate

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

CreateTemplate1

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

CreateTemplateVariable

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

DeleteTemplate

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

DeleteTemplateVariable

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

ExportTemplateToZip

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

GetPossibleTemplateVariableValues

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

GetTemplate

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

GetTemplatePermissions

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

GetTemplateTeams

Example

Path Parameters