version_control_client.go

// Code generated by go-swagger; DO NOT EDIT.

package version_control

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)

// New creates a new version control API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for version control API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	AddCommit(params *AddCommitParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddCommitOK, error)

	AddTag(params *AddTagParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddTagOK, error)

	DeleteBranch(params *DeleteBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteBranchOK, error)

	EditTag(params *EditTagParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*EditTagOK, error)

	GetBranch(params *GetBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetBranchOK, error)

	GetCheckpoint(params *GetCheckpointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCheckpointOK, error)

	GetCommit(params *GetCommitParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCommitOK, error)

	GetCommitHistory(params *GetCommitHistoryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCommitHistoryOK, error)

	GetHARepo(params *GetHARepoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetHARepoOK, error)

	GetOrder(params *GetOrderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrderOK, error)

	GetOrderFromCheckpoint(params *GetOrderFromCheckpointParams, opts ...ClientOption) (*GetOrderFromCheckpointOK, error)

	GetRevertCommit(params *GetRevertCommitParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRevertCommitOK, error)

	MergeBranch(params *MergeBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*MergeBranchOK, error)

	MergeCommits(params *MergeCommitsParams, opts ...ClientOption) (*MergeCommitsOK, *MergeCommitsNoContent, error)

	RemoveTag(params *RemoveTagParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RemoveTagOK, error)

	UpdateBranch(params *UpdateBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateBranchOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  AddCommit add commit API
*/
func (a *Client) AddCommit(params *AddCommitParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddCommitOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddCommitParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addCommit",
		Method:             "POST",
		PathPattern:        "/vcs/commit",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &AddCommitReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AddCommitOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for addCommit: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  AddTag adds tag

  Add a tag by org and project names
*/
func (a *Client) AddTag(params *AddTagParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddTagOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddTagParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addTag",
		Method:             "POST",
		PathPattern:        "/organizations/{organizationName}/projects/{projectName}/tags",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &AddTagReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AddTagOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for addTag: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  DeleteBranch Delete the branch and all descendent forks that are of the same project.  Removes 'tracks' and 'tracking_type' data from all descendent forks in different projects.
*/
func (a *Client) DeleteBranch(params *DeleteBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteBranchOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteBranchParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteBranch",
		Method:             "DELETE",
		PathPattern:        "/vcs/branch/{branchID}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeleteBranchReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteBranchOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteBranch: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  EditTag edits tag

  Edit a tag by org and project names, and tag label
*/
func (a *Client) EditTag(params *EditTagParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*EditTagOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewEditTagParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "editTag",
		Method:             "PUT",
		PathPattern:        "/organizations/{organizationName}/projects/{projectName}/tags/{tagLabel}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &EditTagReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*EditTagOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for editTag: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetBranch get branch API
*/
func (a *Client) GetBranch(params *GetBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetBranchOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetBranchParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getBranch",
		Method:             "GET",
		PathPattern:        "/vcs/branch/{branchID}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetBranchReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetBranchOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getBranch: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCheckpoint get checkpoint API
*/
func (a *Client) GetCheckpoint(params *GetCheckpointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCheckpointOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCheckpointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCheckpoint",
		Method:             "GET",
		PathPattern:        "/vcs/commits/{commitID}/checkpoint",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetCheckpointReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCheckpointOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getCheckpoint: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCommit get commit API
*/
func (a *Client) GetCommit(params *GetCommitParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCommitOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCommitParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCommit",
		Method:             "GET",
		PathPattern:        "/vcs/commits/{commitID}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetCommitReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCommitOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getCommit: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCommitHistory get commit history API
*/
func (a *Client) GetCommitHistory(params *GetCommitHistoryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCommitHistoryOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCommitHistoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCommitHistory",
		Method:             "GET",
		PathPattern:        "/vcs/history/{commitID}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetCommitHistoryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCommitHistoryOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getCommitHistory: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetHARepo gets h a repo info

  Get HARepo by org and project names and HARepo label
*/
func (a *Client) GetHARepo(params *GetHARepoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetHARepoOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetHARepoParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getHARepo",
		Method:             "GET",
		PathPattern:        "/organizations/{organizationName}/projects/{projectName}/harepos/{label}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetHARepoReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetHARepoOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getHARepo: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetOrder get order API
*/
func (a *Client) GetOrder(params *GetOrderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrderOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrderParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getOrder",
		Method:             "GET",
		PathPattern:        "/vcs/commits/{commitID}/order",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetOrderReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetOrderOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getOrder: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetOrderFromCheckpoint get order from checkpoint API
*/
func (a *Client) GetOrderFromCheckpoint(params *GetOrderFromCheckpointParams, opts ...ClientOption) (*GetOrderFromCheckpointOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrderFromCheckpointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getOrderFromCheckpoint",
		Method:             "POST",
		PathPattern:        "/vcs/order",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetOrderFromCheckpointReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetOrderFromCheckpointOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getOrderFromCheckpoint: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetRevertCommit get revert commit API
*/
func (a *Client) GetRevertCommit(params *GetRevertCommitParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRevertCommitOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRevertCommitParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRevertCommit",
		Method:             "GET",
		PathPattern:        "/vcs/commits/{commitFromID}/revert/{commitToID}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetRevertCommitReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetRevertCommitOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getRevertCommit: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  MergeBranch merge branch API
*/
func (a *Client) MergeBranch(params *MergeBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*MergeBranchOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewMergeBranchParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "mergeBranch",
		Method:             "POST",
		PathPattern:        "/vcs/branch/{branchID}/merge",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &MergeBranchReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*MergeBranchOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for mergeBranch: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  MergeCommits merge commits API
*/
func (a *Client) MergeCommits(params *MergeCommitsParams, opts ...ClientOption) (*MergeCommitsOK, *MergeCommitsNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewMergeCommitsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "mergeCommits",
		Method:             "POST",
		PathPattern:        "/vcs/commits/{commitReceivingChanges}/merge/{commitWithChanges}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &MergeCommitsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *MergeCommitsOK:
		return value, nil, nil
	case *MergeCommitsNoContent:
		return nil, value, nil
	}
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for version_control: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  RemoveTag removes tag

  Remove a tag by org and project names, and tag label
*/
func (a *Client) RemoveTag(params *RemoveTagParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RemoveTagOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewRemoveTagParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "removeTag",
		Method:             "DELETE",
		PathPattern:        "/organizations/{organizationName}/projects/{projectName}/tags/{tagLabel}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &RemoveTagReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*RemoveTagOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for removeTag: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  UpdateBranch update branch API
*/
func (a *Client) UpdateBranch(params *UpdateBranchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateBranchOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateBranchParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateBranch",
		Method:             "PUT",
		PathPattern:        "/vcs/branch/{branchID}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UpdateBranchReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*UpdateBranchOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateBranch: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}