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

package repository_management

// 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 repository management API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for repository management 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 {
	CreateRepository(params *CreateRepositoryParams, opts ...ClientOption) (*CreateRepositoryCreated, error)

	CreateRepository1(params *CreateRepository1Params, opts ...ClientOption) (*CreateRepository1Created, error)

	CreateRepository10(params *CreateRepository10Params, opts ...ClientOption) (*CreateRepository10Created, error)

	CreateRepository11(params *CreateRepository11Params, opts ...ClientOption) (*CreateRepository11Created, error)

	CreateRepository12(params *CreateRepository12Params, opts ...ClientOption) (*CreateRepository12Created, error)

	CreateRepository13(params *CreateRepository13Params, opts ...ClientOption) (*CreateRepository13Created, error)

	CreateRepository14(params *CreateRepository14Params, opts ...ClientOption) (*CreateRepository14Created, error)

	CreateRepository15(params *CreateRepository15Params, opts ...ClientOption) (*CreateRepository15Created, error)

	CreateRepository16(params *CreateRepository16Params, opts ...ClientOption) (*CreateRepository16Created, error)

	CreateRepository17(params *CreateRepository17Params, opts ...ClientOption) (*CreateRepository17Created, error)

	CreateRepository18(params *CreateRepository18Params, opts ...ClientOption) (*CreateRepository18Created, error)

	CreateRepository19(params *CreateRepository19Params, opts ...ClientOption) (*CreateRepository19Created, error)

	CreateRepository2(params *CreateRepository2Params, opts ...ClientOption) (*CreateRepository2Created, error)

	CreateRepository20(params *CreateRepository20Params, opts ...ClientOption) (*CreateRepository20Created, error)

	CreateRepository21(params *CreateRepository21Params, opts ...ClientOption) (*CreateRepository21Created, error)

	CreateRepository22(params *CreateRepository22Params, opts ...ClientOption) (*CreateRepository22Created, error)

	CreateRepository23(params *CreateRepository23Params, opts ...ClientOption) (*CreateRepository23Created, error)

	CreateRepository24(params *CreateRepository24Params, opts ...ClientOption) (*CreateRepository24Created, error)

	CreateRepository25(params *CreateRepository25Params, opts ...ClientOption) (*CreateRepository25Created, error)

	CreateRepository26(params *CreateRepository26Params, opts ...ClientOption) (*CreateRepository26Created, error)

	CreateRepository27(params *CreateRepository27Params, opts ...ClientOption) (*CreateRepository27Created, error)

	CreateRepository28(params *CreateRepository28Params, opts ...ClientOption) (*CreateRepository28Created, error)

	CreateRepository29(params *CreateRepository29Params, opts ...ClientOption) (*CreateRepository29Created, error)

	CreateRepository3(params *CreateRepository3Params, opts ...ClientOption) (*CreateRepository3Created, error)

	CreateRepository30(params *CreateRepository30Params, opts ...ClientOption) (*CreateRepository30Created, error)

	CreateRepository31(params *CreateRepository31Params, opts ...ClientOption) (*CreateRepository31Created, error)

	CreateRepository32(params *CreateRepository32Params, opts ...ClientOption) (*CreateRepository32Created, error)

	CreateRepository33(params *CreateRepository33Params, opts ...ClientOption) (*CreateRepository33Created, error)

	CreateRepository34(params *CreateRepository34Params, opts ...ClientOption) (*CreateRepository34Created, error)

	CreateRepository35(params *CreateRepository35Params, opts ...ClientOption) (*CreateRepository35Created, error)

	CreateRepository36(params *CreateRepository36Params, opts ...ClientOption) (*CreateRepository36Created, error)

	CreateRepository37(params *CreateRepository37Params, opts ...ClientOption) (*CreateRepository37Created, error)

	CreateRepository38(params *CreateRepository38Params, opts ...ClientOption) (*CreateRepository38Created, error)

	CreateRepository39(params *CreateRepository39Params, opts ...ClientOption) (*CreateRepository39Created, error)

	CreateRepository4(params *CreateRepository4Params, opts ...ClientOption) (*CreateRepository4Created, error)

	CreateRepository40(params *CreateRepository40Params, opts ...ClientOption) (*CreateRepository40Created, error)

	CreateRepository5(params *CreateRepository5Params, opts ...ClientOption) (*CreateRepository5Created, error)

	CreateRepository6(params *CreateRepository6Params, opts ...ClientOption) (*CreateRepository6Created, error)

	CreateRepository7(params *CreateRepository7Params, opts ...ClientOption) (*CreateRepository7Created, error)

	CreateRepository8(params *CreateRepository8Params, opts ...ClientOption) (*CreateRepository8Created, error)

	CreateRepository9(params *CreateRepository9Params, opts ...ClientOption) (*CreateRepository9Created, error)

	DeleteRepository(params *DeleteRepositoryParams, opts ...ClientOption) (*DeleteRepositoryNoContent, error)

	DisableRepositoryHealthCheck(params *DisableRepositoryHealthCheckParams, opts ...ClientOption) (*DisableRepositoryHealthCheckNoContent, error)

	EnableRepositoryHealthCheck(params *EnableRepositoryHealthCheckParams, opts ...ClientOption) (*EnableRepositoryHealthCheckNoContent, error)

	GetRepositories(params *GetRepositoriesParams, opts ...ClientOption) (*GetRepositoriesOK, error)

	GetRepositories1(params *GetRepositories1Params, opts ...ClientOption) (*GetRepositories1OK, error)

	GetRepository(params *GetRepositoryParams, opts ...ClientOption) (*GetRepositoryOK, error)

	GetRepository1(params *GetRepository1Params, opts ...ClientOption) (*GetRepository1OK, error)

	GetRepository10(params *GetRepository10Params, opts ...ClientOption) (*GetRepository10OK, error)

	GetRepository11(params *GetRepository11Params, opts ...ClientOption) (*GetRepository11OK, error)

	GetRepository12(params *GetRepository12Params, opts ...ClientOption) (*GetRepository12OK, error)

	GetRepository13(params *GetRepository13Params, opts ...ClientOption) (*GetRepository13OK, error)

	GetRepository14(params *GetRepository14Params, opts ...ClientOption) (*GetRepository14OK, error)

	GetRepository15(params *GetRepository15Params, opts ...ClientOption) (*GetRepository15OK, error)

	GetRepository16(params *GetRepository16Params, opts ...ClientOption) (*GetRepository16OK, error)

	GetRepository17(params *GetRepository17Params, opts ...ClientOption) (*GetRepository17OK, error)

	GetRepository18(params *GetRepository18Params, opts ...ClientOption) (*GetRepository18OK, error)

	GetRepository19(params *GetRepository19Params, opts ...ClientOption) (*GetRepository19OK, error)

	GetRepository2(params *GetRepository2Params, opts ...ClientOption) (*GetRepository2OK, error)

	GetRepository20(params *GetRepository20Params, opts ...ClientOption) (*GetRepository20OK, error)

	GetRepository21(params *GetRepository21Params, opts ...ClientOption) (*GetRepository21OK, error)

	GetRepository22(params *GetRepository22Params, opts ...ClientOption) (*GetRepository22OK, error)

	GetRepository23(params *GetRepository23Params, opts ...ClientOption) (*GetRepository23OK, error)

	GetRepository24(params *GetRepository24Params, opts ...ClientOption) (*GetRepository24OK, error)

	GetRepository25(params *GetRepository25Params, opts ...ClientOption) (*GetRepository25OK, error)

	GetRepository26(params *GetRepository26Params, opts ...ClientOption) (*GetRepository26OK, error)

	GetRepository27(params *GetRepository27Params, opts ...ClientOption) (*GetRepository27OK, error)

	GetRepository28(params *GetRepository28Params, opts ...ClientOption) (*GetRepository28OK, error)

	GetRepository29(params *GetRepository29Params, opts ...ClientOption) (*GetRepository29OK, error)

	GetRepository3(params *GetRepository3Params, opts ...ClientOption) (*GetRepository3OK, error)

	GetRepository30(params *GetRepository30Params, opts ...ClientOption) (*GetRepository30OK, error)

	GetRepository31(params *GetRepository31Params, opts ...ClientOption) (*GetRepository31OK, error)

	GetRepository32(params *GetRepository32Params, opts ...ClientOption) (*GetRepository32OK, error)

	GetRepository33(params *GetRepository33Params, opts ...ClientOption) (*GetRepository33OK, error)

	GetRepository34(params *GetRepository34Params, opts ...ClientOption) (*GetRepository34OK, error)

	GetRepository35(params *GetRepository35Params, opts ...ClientOption) (*GetRepository35OK, error)

	GetRepository36(params *GetRepository36Params, opts ...ClientOption) (*GetRepository36OK, error)

	GetRepository37(params *GetRepository37Params, opts ...ClientOption) (*GetRepository37OK, error)

	GetRepository38(params *GetRepository38Params, opts ...ClientOption) (*GetRepository38OK, error)

	GetRepository39(params *GetRepository39Params, opts ...ClientOption) (*GetRepository39OK, error)

	GetRepository4(params *GetRepository4Params, opts ...ClientOption) (*GetRepository4OK, error)

	GetRepository40(params *GetRepository40Params, opts ...ClientOption) (*GetRepository40OK, error)

	GetRepository41(params *GetRepository41Params, opts ...ClientOption) (*GetRepository41OK, error)

	GetRepository5(params *GetRepository5Params, opts ...ClientOption) (*GetRepository5OK, error)

	GetRepository6(params *GetRepository6Params, opts ...ClientOption) (*GetRepository6OK, error)

	GetRepository7(params *GetRepository7Params, opts ...ClientOption) (*GetRepository7OK, error)

	GetRepository8(params *GetRepository8Params, opts ...ClientOption) (*GetRepository8OK, error)

	GetRepository9(params *GetRepository9Params, opts ...ClientOption) (*GetRepository9OK, error)

	InvalidateCache(params *InvalidateCacheParams, opts ...ClientOption) (*InvalidateCacheNoContent, error)

	RebuildIndex(params *RebuildIndexParams, opts ...ClientOption) (*RebuildIndexNoContent, error)

	UpdateRepository(params *UpdateRepositoryParams, opts ...ClientOption) (*UpdateRepositoryNoContent, error)

	UpdateRepository1(params *UpdateRepository1Params, opts ...ClientOption) (*UpdateRepository1NoContent, error)

	UpdateRepository10(params *UpdateRepository10Params, opts ...ClientOption) (*UpdateRepository10NoContent, error)

	UpdateRepository11(params *UpdateRepository11Params, opts ...ClientOption) (*UpdateRepository11NoContent, error)

	UpdateRepository12(params *UpdateRepository12Params, opts ...ClientOption) (*UpdateRepository12NoContent, error)

	UpdateRepository13(params *UpdateRepository13Params, opts ...ClientOption) (*UpdateRepository13NoContent, error)

	UpdateRepository14(params *UpdateRepository14Params, opts ...ClientOption) (*UpdateRepository14NoContent, error)

	UpdateRepository15(params *UpdateRepository15Params, opts ...ClientOption) (*UpdateRepository15NoContent, error)

	UpdateRepository16(params *UpdateRepository16Params, opts ...ClientOption) (*UpdateRepository16NoContent, error)

	UpdateRepository17(params *UpdateRepository17Params, opts ...ClientOption) (*UpdateRepository17NoContent, error)

	UpdateRepository18(params *UpdateRepository18Params, opts ...ClientOption) (*UpdateRepository18NoContent, error)

	UpdateRepository19(params *UpdateRepository19Params, opts ...ClientOption) (*UpdateRepository19NoContent, error)

	UpdateRepository2(params *UpdateRepository2Params, opts ...ClientOption) (*UpdateRepository2NoContent, error)

	UpdateRepository20(params *UpdateRepository20Params, opts ...ClientOption) (*UpdateRepository20NoContent, error)

	UpdateRepository21(params *UpdateRepository21Params, opts ...ClientOption) (*UpdateRepository21NoContent, error)

	UpdateRepository22(params *UpdateRepository22Params, opts ...ClientOption) (*UpdateRepository22NoContent, error)

	UpdateRepository23(params *UpdateRepository23Params, opts ...ClientOption) (*UpdateRepository23NoContent, error)

	UpdateRepository24(params *UpdateRepository24Params, opts ...ClientOption) (*UpdateRepository24NoContent, error)

	UpdateRepository25(params *UpdateRepository25Params, opts ...ClientOption) (*UpdateRepository25NoContent, error)

	UpdateRepository26(params *UpdateRepository26Params, opts ...ClientOption) (*UpdateRepository26NoContent, error)

	UpdateRepository27(params *UpdateRepository27Params, opts ...ClientOption) (*UpdateRepository27NoContent, error)

	UpdateRepository28(params *UpdateRepository28Params, opts ...ClientOption) (*UpdateRepository28NoContent, error)

	UpdateRepository29(params *UpdateRepository29Params, opts ...ClientOption) (*UpdateRepository29NoContent, error)

	UpdateRepository3(params *UpdateRepository3Params, opts ...ClientOption) (*UpdateRepository3NoContent, error)

	UpdateRepository30(params *UpdateRepository30Params, opts ...ClientOption) (*UpdateRepository30NoContent, error)

	UpdateRepository31(params *UpdateRepository31Params, opts ...ClientOption) (*UpdateRepository31NoContent, error)

	UpdateRepository32(params *UpdateRepository32Params, opts ...ClientOption) (*UpdateRepository32NoContent, error)

	UpdateRepository33(params *UpdateRepository33Params, opts ...ClientOption) (*UpdateRepository33NoContent, error)

	UpdateRepository34(params *UpdateRepository34Params, opts ...ClientOption) (*UpdateRepository34NoContent, error)

	UpdateRepository35(params *UpdateRepository35Params, opts ...ClientOption) (*UpdateRepository35NoContent, error)

	UpdateRepository36(params *UpdateRepository36Params, opts ...ClientOption) (*UpdateRepository36NoContent, error)

	UpdateRepository37(params *UpdateRepository37Params, opts ...ClientOption) (*UpdateRepository37NoContent, error)

	UpdateRepository38(params *UpdateRepository38Params, opts ...ClientOption) (*UpdateRepository38NoContent, error)

	UpdateRepository39(params *UpdateRepository39Params, opts ...ClientOption) (*UpdateRepository39NoContent, error)

	UpdateRepository4(params *UpdateRepository4Params, opts ...ClientOption) (*UpdateRepository4NoContent, error)

	UpdateRepository40(params *UpdateRepository40Params, opts ...ClientOption) (*UpdateRepository40NoContent, error)

	UpdateRepository5(params *UpdateRepository5Params, opts ...ClientOption) (*UpdateRepository5NoContent, error)

	UpdateRepository6(params *UpdateRepository6Params, opts ...ClientOption) (*UpdateRepository6NoContent, error)

	UpdateRepository7(params *UpdateRepository7Params, opts ...ClientOption) (*UpdateRepository7NoContent, error)

	UpdateRepository8(params *UpdateRepository8Params, opts ...ClientOption) (*UpdateRepository8NoContent, error)

	UpdateRepository9(params *UpdateRepository9Params, opts ...ClientOption) (*UpdateRepository9NoContent, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
CreateRepository creates maven group repository
*/
func (a *Client) CreateRepository(params *CreateRepositoryParams, opts ...ClientOption) (*CreateRepositoryCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepositoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository",
		Method:             "POST",
		PathPattern:        "/v1/repositories/maven/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepositoryReader{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.(*CreateRepositoryCreated)
	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 createRepository: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository1 creates maven hosted repository
*/
func (a *Client) CreateRepository1(params *CreateRepository1Params, opts ...ClientOption) (*CreateRepository1Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository1Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_1",
		Method:             "POST",
		PathPattern:        "/v1/repositories/maven/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository1Reader{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.(*CreateRepository1Created)
	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 createRepository_1: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository10 creates npm proxy repository
*/
func (a *Client) CreateRepository10(params *CreateRepository10Params, opts ...ClientOption) (*CreateRepository10Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository10Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_10",
		Method:             "POST",
		PathPattern:        "/v1/repositories/npm/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository10Reader{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.(*CreateRepository10Created)
	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 createRepository_10: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository11 creates nu get group repository
*/
func (a *Client) CreateRepository11(params *CreateRepository11Params, opts ...ClientOption) (*CreateRepository11Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository11Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_11",
		Method:             "POST",
		PathPattern:        "/v1/repositories/nuget/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository11Reader{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.(*CreateRepository11Created)
	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 createRepository_11: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository12 creates nu get hosted repository
*/
func (a *Client) CreateRepository12(params *CreateRepository12Params, opts ...ClientOption) (*CreateRepository12Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository12Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_12",
		Method:             "POST",
		PathPattern:        "/v1/repositories/nuget/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository12Reader{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.(*CreateRepository12Created)
	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 createRepository_12: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository13 creates nu get proxy repository
*/
func (a *Client) CreateRepository13(params *CreateRepository13Params, opts ...ClientOption) (*CreateRepository13Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository13Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_13",
		Method:             "POST",
		PathPattern:        "/v1/repositories/nuget/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository13Reader{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.(*CreateRepository13Created)
	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 createRepository_13: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository14 creates ruby gems group repository
*/
func (a *Client) CreateRepository14(params *CreateRepository14Params, opts ...ClientOption) (*CreateRepository14Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository14Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_14",
		Method:             "POST",
		PathPattern:        "/v1/repositories/rubygems/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository14Reader{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.(*CreateRepository14Created)
	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 createRepository_14: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository15 creates ruby gems hosted repository
*/
func (a *Client) CreateRepository15(params *CreateRepository15Params, opts ...ClientOption) (*CreateRepository15Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository15Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_15",
		Method:             "POST",
		PathPattern:        "/v1/repositories/rubygems/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository15Reader{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.(*CreateRepository15Created)
	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 createRepository_15: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository16 creates ruby gems proxy repository
*/
func (a *Client) CreateRepository16(params *CreateRepository16Params, opts ...ClientOption) (*CreateRepository16Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository16Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_16",
		Method:             "POST",
		PathPattern:        "/v1/repositories/rubygems/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository16Reader{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.(*CreateRepository16Created)
	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 createRepository_16: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository17 creates docker group repository
*/
func (a *Client) CreateRepository17(params *CreateRepository17Params, opts ...ClientOption) (*CreateRepository17Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository17Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_17",
		Method:             "POST",
		PathPattern:        "/v1/repositories/docker/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository17Reader{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.(*CreateRepository17Created)
	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 createRepository_17: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository18 creates docker hosted repository
*/
func (a *Client) CreateRepository18(params *CreateRepository18Params, opts ...ClientOption) (*CreateRepository18Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository18Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_18",
		Method:             "POST",
		PathPattern:        "/v1/repositories/docker/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository18Reader{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.(*CreateRepository18Created)
	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 createRepository_18: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository19 creates docker proxy repository
*/
func (a *Client) CreateRepository19(params *CreateRepository19Params, opts ...ClientOption) (*CreateRepository19Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository19Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_19",
		Method:             "POST",
		PathPattern:        "/v1/repositories/docker/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository19Reader{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.(*CreateRepository19Created)
	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 createRepository_19: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository2 creates maven proxy repository
*/
func (a *Client) CreateRepository2(params *CreateRepository2Params, opts ...ClientOption) (*CreateRepository2Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository2Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_2",
		Method:             "POST",
		PathPattern:        "/v1/repositories/maven/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository2Reader{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.(*CreateRepository2Created)
	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 createRepository_2: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository20 creates yum group repository
*/
func (a *Client) CreateRepository20(params *CreateRepository20Params, opts ...ClientOption) (*CreateRepository20Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository20Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_20",
		Method:             "POST",
		PathPattern:        "/v1/repositories/yum/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository20Reader{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.(*CreateRepository20Created)
	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 createRepository_20: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository21 creates yum hosted repository
*/
func (a *Client) CreateRepository21(params *CreateRepository21Params, opts ...ClientOption) (*CreateRepository21Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository21Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_21",
		Method:             "POST",
		PathPattern:        "/v1/repositories/yum/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository21Reader{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.(*CreateRepository21Created)
	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 createRepository_21: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository22 creates yum proxy repository
*/
func (a *Client) CreateRepository22(params *CreateRepository22Params, opts ...ClientOption) (*CreateRepository22Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository22Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_22",
		Method:             "POST",
		PathPattern:        "/v1/repositories/yum/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository22Reader{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.(*CreateRepository22Created)
	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 createRepository_22: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository23 creates helm hosted repository
*/
func (a *Client) CreateRepository23(params *CreateRepository23Params, opts ...ClientOption) (*CreateRepository23Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository23Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_23",
		Method:             "POST",
		PathPattern:        "/v1/repositories/helm/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository23Reader{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.(*CreateRepository23Created)
	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 createRepository_23: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository24 creates helm proxy repository
*/
func (a *Client) CreateRepository24(params *CreateRepository24Params, opts ...ClientOption) (*CreateRepository24Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository24Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_24",
		Method:             "POST",
		PathPattern:        "/v1/repositories/helm/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository24Reader{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.(*CreateRepository24Created)
	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 createRepository_24: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository25 creates git l f s hosted repository
*/
func (a *Client) CreateRepository25(params *CreateRepository25Params, opts ...ClientOption) (*CreateRepository25Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository25Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_25",
		Method:             "POST",
		PathPattern:        "/v1/repositories/gitlfs/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository25Reader{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.(*CreateRepository25Created)
	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 createRepository_25: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository26 creates py p i group repository
*/
func (a *Client) CreateRepository26(params *CreateRepository26Params, opts ...ClientOption) (*CreateRepository26Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository26Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_26",
		Method:             "POST",
		PathPattern:        "/v1/repositories/pypi/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository26Reader{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.(*CreateRepository26Created)
	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 createRepository_26: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository27 creates py p i hosted repository
*/
func (a *Client) CreateRepository27(params *CreateRepository27Params, opts ...ClientOption) (*CreateRepository27Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository27Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_27",
		Method:             "POST",
		PathPattern:        "/v1/repositories/pypi/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository27Reader{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.(*CreateRepository27Created)
	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 createRepository_27: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository28 creates py p i proxy repository
*/
func (a *Client) CreateRepository28(params *CreateRepository28Params, opts ...ClientOption) (*CreateRepository28Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository28Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_28",
		Method:             "POST",
		PathPattern:        "/v1/repositories/pypi/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository28Reader{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.(*CreateRepository28Created)
	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 createRepository_28: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository29 creates conda proxy repository
*/
func (a *Client) CreateRepository29(params *CreateRepository29Params, opts ...ClientOption) (*CreateRepository29Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository29Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_29",
		Method:             "POST",
		PathPattern:        "/v1/repositories/conda/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository29Reader{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.(*CreateRepository29Created)
	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 createRepository_29: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository3 creates a p t hosted repository
*/
func (a *Client) CreateRepository3(params *CreateRepository3Params, opts ...ClientOption) (*CreateRepository3Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository3Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_3",
		Method:             "POST",
		PathPattern:        "/v1/repositories/apt/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository3Reader{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.(*CreateRepository3Created)
	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 createRepository_3: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository30 creates conan proxy repository
*/
func (a *Client) CreateRepository30(params *CreateRepository30Params, opts ...ClientOption) (*CreateRepository30Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository30Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_30",
		Method:             "POST",
		PathPattern:        "/v1/repositories/conan/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository30Reader{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.(*CreateRepository30Created)
	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 createRepository_30: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository31 creates r group repository
*/
func (a *Client) CreateRepository31(params *CreateRepository31Params, opts ...ClientOption) (*CreateRepository31Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository31Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_31",
		Method:             "POST",
		PathPattern:        "/v1/repositories/r/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository31Reader{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.(*CreateRepository31Created)
	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 createRepository_31: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository32 creates r hosted repository
*/
func (a *Client) CreateRepository32(params *CreateRepository32Params, opts ...ClientOption) (*CreateRepository32Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository32Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_32",
		Method:             "POST",
		PathPattern:        "/v1/repositories/r/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository32Reader{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.(*CreateRepository32Created)
	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 createRepository_32: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository33 creates r proxy repository
*/
func (a *Client) CreateRepository33(params *CreateRepository33Params, opts ...ClientOption) (*CreateRepository33Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository33Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_33",
		Method:             "POST",
		PathPattern:        "/v1/repositories/r/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository33Reader{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.(*CreateRepository33Created)
	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 createRepository_33: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository34 creates cocoapods proxy repository
*/
func (a *Client) CreateRepository34(params *CreateRepository34Params, opts ...ClientOption) (*CreateRepository34Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository34Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_34",
		Method:             "POST",
		PathPattern:        "/v1/repositories/cocoapods/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository34Reader{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.(*CreateRepository34Created)
	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 createRepository_34: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository35 creates a go group repository
*/
func (a *Client) CreateRepository35(params *CreateRepository35Params, opts ...ClientOption) (*CreateRepository35Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository35Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_35",
		Method:             "POST",
		PathPattern:        "/v1/repositories/go/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository35Reader{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.(*CreateRepository35Created)
	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 createRepository_35: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository36 creates a go proxy repository
*/
func (a *Client) CreateRepository36(params *CreateRepository36Params, opts ...ClientOption) (*CreateRepository36Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository36Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_36",
		Method:             "POST",
		PathPattern:        "/v1/repositories/go/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository36Reader{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.(*CreateRepository36Created)
	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 createRepository_36: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository37 creates p2 proxy repository
*/
func (a *Client) CreateRepository37(params *CreateRepository37Params, opts ...ClientOption) (*CreateRepository37Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository37Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_37",
		Method:             "POST",
		PathPattern:        "/v1/repositories/p2/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository37Reader{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.(*CreateRepository37Created)
	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 createRepository_37: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository38 creates bower group repository
*/
func (a *Client) CreateRepository38(params *CreateRepository38Params, opts ...ClientOption) (*CreateRepository38Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository38Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_38",
		Method:             "POST",
		PathPattern:        "/v1/repositories/bower/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository38Reader{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.(*CreateRepository38Created)
	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 createRepository_38: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository39 creates bower hosted repository
*/
func (a *Client) CreateRepository39(params *CreateRepository39Params, opts ...ClientOption) (*CreateRepository39Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository39Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_39",
		Method:             "POST",
		PathPattern:        "/v1/repositories/bower/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository39Reader{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.(*CreateRepository39Created)
	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 createRepository_39: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository4 creates a p t proxy repository
*/
func (a *Client) CreateRepository4(params *CreateRepository4Params, opts ...ClientOption) (*CreateRepository4Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository4Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_4",
		Method:             "POST",
		PathPattern:        "/v1/repositories/apt/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository4Reader{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.(*CreateRepository4Created)
	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 createRepository_4: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository40 creates bower proxy repository
*/
func (a *Client) CreateRepository40(params *CreateRepository40Params, opts ...ClientOption) (*CreateRepository40Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository40Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_40",
		Method:             "POST",
		PathPattern:        "/v1/repositories/bower/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository40Reader{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.(*CreateRepository40Created)
	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 createRepository_40: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository5 creates raw group repository
*/
func (a *Client) CreateRepository5(params *CreateRepository5Params, opts ...ClientOption) (*CreateRepository5Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository5Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_5",
		Method:             "POST",
		PathPattern:        "/v1/repositories/raw/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository5Reader{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.(*CreateRepository5Created)
	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 createRepository_5: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository6 creates raw hosted repository
*/
func (a *Client) CreateRepository6(params *CreateRepository6Params, opts ...ClientOption) (*CreateRepository6Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository6Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_6",
		Method:             "POST",
		PathPattern:        "/v1/repositories/raw/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository6Reader{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.(*CreateRepository6Created)
	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 createRepository_6: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository7 creates raw proxy repository
*/
func (a *Client) CreateRepository7(params *CreateRepository7Params, opts ...ClientOption) (*CreateRepository7Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository7Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_7",
		Method:             "POST",
		PathPattern:        "/v1/repositories/raw/proxy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository7Reader{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.(*CreateRepository7Created)
	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 createRepository_7: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository8 creates npm group repository
*/
func (a *Client) CreateRepository8(params *CreateRepository8Params, opts ...ClientOption) (*CreateRepository8Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository8Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_8",
		Method:             "POST",
		PathPattern:        "/v1/repositories/npm/group",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository8Reader{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.(*CreateRepository8Created)
	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 createRepository_8: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateRepository9 creates npm hosted repository
*/
func (a *Client) CreateRepository9(params *CreateRepository9Params, opts ...ClientOption) (*CreateRepository9Created, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateRepository9Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "createRepository_9",
		Method:             "POST",
		PathPattern:        "/v1/repositories/npm/hosted",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateRepository9Reader{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.(*CreateRepository9Created)
	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 createRepository_9: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteRepository deletes repository of any format
*/
func (a *Client) DeleteRepository(params *DeleteRepositoryParams, opts ...ClientOption) (*DeleteRepositoryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteRepositoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteRepository",
		Method:             "DELETE",
		PathPattern:        "/v1/repositories/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteRepositoryReader{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.(*DeleteRepositoryNoContent)
	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 deleteRepository: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DisableRepositoryHealthCheck disables repository health check proxy repositories only
*/
func (a *Client) DisableRepositoryHealthCheck(params *DisableRepositoryHealthCheckParams, opts ...ClientOption) (*DisableRepositoryHealthCheckNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDisableRepositoryHealthCheckParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "disableRepositoryHealthCheck",
		Method:             "DELETE",
		PathPattern:        "/v1/repositories/{repositoryName}/health-check",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DisableRepositoryHealthCheckReader{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.(*DisableRepositoryHealthCheckNoContent)
	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 disableRepositoryHealthCheck: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
EnableRepositoryHealthCheck enables repository health check proxy repositories only
*/
func (a *Client) EnableRepositoryHealthCheck(params *EnableRepositoryHealthCheckParams, opts ...ClientOption) (*EnableRepositoryHealthCheckNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewEnableRepositoryHealthCheckParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "enableRepositoryHealthCheck",
		Method:             "POST",
		PathPattern:        "/v1/repositories/{repositoryName}/health-check",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &EnableRepositoryHealthCheckReader{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.(*EnableRepositoryHealthCheckNoContent)
	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 enableRepositoryHealthCheck: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepositories lists repositories
*/
func (a *Client) GetRepositories(params *GetRepositoriesParams, opts ...ClientOption) (*GetRepositoriesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepositoriesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepositories",
		Method:             "GET",
		PathPattern:        "/v1/repositorySettings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepositoriesReader{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.(*GetRepositoriesOK)
	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 getRepositories: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepositories1 lists repositories
*/
func (a *Client) GetRepositories1(params *GetRepositories1Params, opts ...ClientOption) (*GetRepositories1OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepositories1Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepositories_1",
		Method:             "GET",
		PathPattern:        "/v1/repositories",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepositories1Reader{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.(*GetRepositories1OK)
	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 getRepositories_1: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository gets repository details
*/
func (a *Client) GetRepository(params *GetRepositoryParams, opts ...ClientOption) (*GetRepositoryOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepositoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository",
		Method:             "GET",
		PathPattern:        "/v1/repositories/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepositoryReader{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.(*GetRepositoryOK)
	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 getRepository: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository1 gets repository
*/
func (a *Client) GetRepository1(params *GetRepository1Params, opts ...ClientOption) (*GetRepository1OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository1Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_1",
		Method:             "GET",
		PathPattern:        "/v1/repositories/maven/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository1Reader{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.(*GetRepository1OK)
	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 getRepository_1: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository10 gets repository
*/
func (a *Client) GetRepository10(params *GetRepository10Params, opts ...ClientOption) (*GetRepository10OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository10Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_10",
		Method:             "GET",
		PathPattern:        "/v1/repositories/npm/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository10Reader{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.(*GetRepository10OK)
	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 getRepository_10: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository11 gets repository
*/
func (a *Client) GetRepository11(params *GetRepository11Params, opts ...ClientOption) (*GetRepository11OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository11Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_11",
		Method:             "GET",
		PathPattern:        "/v1/repositories/npm/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository11Reader{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.(*GetRepository11OK)
	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 getRepository_11: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository12 gets repository
*/
func (a *Client) GetRepository12(params *GetRepository12Params, opts ...ClientOption) (*GetRepository12OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository12Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_12",
		Method:             "GET",
		PathPattern:        "/v1/repositories/nuget/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository12Reader{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.(*GetRepository12OK)
	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 getRepository_12: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository13 gets repository
*/
func (a *Client) GetRepository13(params *GetRepository13Params, opts ...ClientOption) (*GetRepository13OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository13Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_13",
		Method:             "GET",
		PathPattern:        "/v1/repositories/nuget/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository13Reader{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.(*GetRepository13OK)
	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 getRepository_13: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository14 gets repository
*/
func (a *Client) GetRepository14(params *GetRepository14Params, opts ...ClientOption) (*GetRepository14OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository14Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_14",
		Method:             "GET",
		PathPattern:        "/v1/repositories/nuget/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository14Reader{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.(*GetRepository14OK)
	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 getRepository_14: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository15 gets repository
*/
func (a *Client) GetRepository15(params *GetRepository15Params, opts ...ClientOption) (*GetRepository15OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository15Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_15",
		Method:             "GET",
		PathPattern:        "/v1/repositories/rubygems/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository15Reader{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.(*GetRepository15OK)
	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 getRepository_15: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository16 gets repository
*/
func (a *Client) GetRepository16(params *GetRepository16Params, opts ...ClientOption) (*GetRepository16OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository16Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_16",
		Method:             "GET",
		PathPattern:        "/v1/repositories/rubygems/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository16Reader{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.(*GetRepository16OK)
	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 getRepository_16: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository17 gets repository
*/
func (a *Client) GetRepository17(params *GetRepository17Params, opts ...ClientOption) (*GetRepository17OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository17Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_17",
		Method:             "GET",
		PathPattern:        "/v1/repositories/rubygems/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository17Reader{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.(*GetRepository17OK)
	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 getRepository_17: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository18 gets repository
*/
func (a *Client) GetRepository18(params *GetRepository18Params, opts ...ClientOption) (*GetRepository18OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository18Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_18",
		Method:             "GET",
		PathPattern:        "/v1/repositories/docker/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository18Reader{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.(*GetRepository18OK)
	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 getRepository_18: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository19 gets repository
*/
func (a *Client) GetRepository19(params *GetRepository19Params, opts ...ClientOption) (*GetRepository19OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository19Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_19",
		Method:             "GET",
		PathPattern:        "/v1/repositories/docker/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository19Reader{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.(*GetRepository19OK)
	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 getRepository_19: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository2 gets repository
*/
func (a *Client) GetRepository2(params *GetRepository2Params, opts ...ClientOption) (*GetRepository2OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository2Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_2",
		Method:             "GET",
		PathPattern:        "/v1/repositories/maven/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository2Reader{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.(*GetRepository2OK)
	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 getRepository_2: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository20 gets repository
*/
func (a *Client) GetRepository20(params *GetRepository20Params, opts ...ClientOption) (*GetRepository20OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository20Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_20",
		Method:             "GET",
		PathPattern:        "/v1/repositories/docker/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository20Reader{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.(*GetRepository20OK)
	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 getRepository_20: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository21 gets repository
*/
func (a *Client) GetRepository21(params *GetRepository21Params, opts ...ClientOption) (*GetRepository21OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository21Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_21",
		Method:             "GET",
		PathPattern:        "/v1/repositories/yum/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository21Reader{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.(*GetRepository21OK)
	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 getRepository_21: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository22 gets repository
*/
func (a *Client) GetRepository22(params *GetRepository22Params, opts ...ClientOption) (*GetRepository22OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository22Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_22",
		Method:             "GET",
		PathPattern:        "/v1/repositories/yum/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository22Reader{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.(*GetRepository22OK)
	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 getRepository_22: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository23 gets repository
*/
func (a *Client) GetRepository23(params *GetRepository23Params, opts ...ClientOption) (*GetRepository23OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository23Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_23",
		Method:             "GET",
		PathPattern:        "/v1/repositories/yum/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository23Reader{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.(*GetRepository23OK)
	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 getRepository_23: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository24 gets repository
*/
func (a *Client) GetRepository24(params *GetRepository24Params, opts ...ClientOption) (*GetRepository24OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository24Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_24",
		Method:             "GET",
		PathPattern:        "/v1/repositories/helm/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository24Reader{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.(*GetRepository24OK)
	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 getRepository_24: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository25 gets repository
*/
func (a *Client) GetRepository25(params *GetRepository25Params, opts ...ClientOption) (*GetRepository25OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository25Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_25",
		Method:             "GET",
		PathPattern:        "/v1/repositories/helm/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository25Reader{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.(*GetRepository25OK)
	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 getRepository_25: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository26 gets repository
*/
func (a *Client) GetRepository26(params *GetRepository26Params, opts ...ClientOption) (*GetRepository26OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository26Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_26",
		Method:             "GET",
		PathPattern:        "/v1/repositories/gitlfs/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository26Reader{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.(*GetRepository26OK)
	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 getRepository_26: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository27 gets repository
*/
func (a *Client) GetRepository27(params *GetRepository27Params, opts ...ClientOption) (*GetRepository27OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository27Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_27",
		Method:             "GET",
		PathPattern:        "/v1/repositories/pypi/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository27Reader{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.(*GetRepository27OK)
	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 getRepository_27: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository28 gets repository
*/
func (a *Client) GetRepository28(params *GetRepository28Params, opts ...ClientOption) (*GetRepository28OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository28Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_28",
		Method:             "GET",
		PathPattern:        "/v1/repositories/pypi/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository28Reader{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.(*GetRepository28OK)
	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 getRepository_28: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository29 gets repository
*/
func (a *Client) GetRepository29(params *GetRepository29Params, opts ...ClientOption) (*GetRepository29OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository29Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_29",
		Method:             "GET",
		PathPattern:        "/v1/repositories/pypi/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository29Reader{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.(*GetRepository29OK)
	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 getRepository_29: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository3 gets repository
*/
func (a *Client) GetRepository3(params *GetRepository3Params, opts ...ClientOption) (*GetRepository3OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository3Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_3",
		Method:             "GET",
		PathPattern:        "/v1/repositories/maven/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository3Reader{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.(*GetRepository3OK)
	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 getRepository_3: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository30 gets repository
*/
func (a *Client) GetRepository30(params *GetRepository30Params, opts ...ClientOption) (*GetRepository30OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository30Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_30",
		Method:             "GET",
		PathPattern:        "/v1/repositories/conda/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository30Reader{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.(*GetRepository30OK)
	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 getRepository_30: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository31 gets repository
*/
func (a *Client) GetRepository31(params *GetRepository31Params, opts ...ClientOption) (*GetRepository31OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository31Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_31",
		Method:             "GET",
		PathPattern:        "/v1/repositories/conan/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository31Reader{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.(*GetRepository31OK)
	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 getRepository_31: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository32 gets repository
*/
func (a *Client) GetRepository32(params *GetRepository32Params, opts ...ClientOption) (*GetRepository32OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository32Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_32",
		Method:             "GET",
		PathPattern:        "/v1/repositories/r/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository32Reader{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.(*GetRepository32OK)
	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 getRepository_32: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository33 gets repository
*/
func (a *Client) GetRepository33(params *GetRepository33Params, opts ...ClientOption) (*GetRepository33OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository33Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_33",
		Method:             "GET",
		PathPattern:        "/v1/repositories/r/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository33Reader{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.(*GetRepository33OK)
	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 getRepository_33: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository34 gets repository
*/
func (a *Client) GetRepository34(params *GetRepository34Params, opts ...ClientOption) (*GetRepository34OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository34Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_34",
		Method:             "GET",
		PathPattern:        "/v1/repositories/r/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository34Reader{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.(*GetRepository34OK)
	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 getRepository_34: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository35 gets repository
*/
func (a *Client) GetRepository35(params *GetRepository35Params, opts ...ClientOption) (*GetRepository35OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository35Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_35",
		Method:             "GET",
		PathPattern:        "/v1/repositories/cocoapods/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository35Reader{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.(*GetRepository35OK)
	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 getRepository_35: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository36 gets repository
*/
func (a *Client) GetRepository36(params *GetRepository36Params, opts ...ClientOption) (*GetRepository36OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository36Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_36",
		Method:             "GET",
		PathPattern:        "/v1/repositories/go/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository36Reader{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.(*GetRepository36OK)
	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 getRepository_36: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository37 gets repository
*/
func (a *Client) GetRepository37(params *GetRepository37Params, opts ...ClientOption) (*GetRepository37OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository37Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_37",
		Method:             "GET",
		PathPattern:        "/v1/repositories/go/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository37Reader{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.(*GetRepository37OK)
	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 getRepository_37: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository38 gets repository
*/
func (a *Client) GetRepository38(params *GetRepository38Params, opts ...ClientOption) (*GetRepository38OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository38Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_38",
		Method:             "GET",
		PathPattern:        "/v1/repositories/p2/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository38Reader{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.(*GetRepository38OK)
	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 getRepository_38: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository39 gets repository
*/
func (a *Client) GetRepository39(params *GetRepository39Params, opts ...ClientOption) (*GetRepository39OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository39Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_39",
		Method:             "GET",
		PathPattern:        "/v1/repositories/bower/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository39Reader{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.(*GetRepository39OK)
	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 getRepository_39: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository4 gets repository
*/
func (a *Client) GetRepository4(params *GetRepository4Params, opts ...ClientOption) (*GetRepository4OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository4Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_4",
		Method:             "GET",
		PathPattern:        "/v1/repositories/apt/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository4Reader{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.(*GetRepository4OK)
	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 getRepository_4: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository40 gets repository
*/
func (a *Client) GetRepository40(params *GetRepository40Params, opts ...ClientOption) (*GetRepository40OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository40Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_40",
		Method:             "GET",
		PathPattern:        "/v1/repositories/bower/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository40Reader{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.(*GetRepository40OK)
	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 getRepository_40: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository41 gets repository
*/
func (a *Client) GetRepository41(params *GetRepository41Params, opts ...ClientOption) (*GetRepository41OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository41Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_41",
		Method:             "GET",
		PathPattern:        "/v1/repositories/bower/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository41Reader{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.(*GetRepository41OK)
	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 getRepository_41: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository5 gets repository
*/
func (a *Client) GetRepository5(params *GetRepository5Params, opts ...ClientOption) (*GetRepository5OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository5Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_5",
		Method:             "GET",
		PathPattern:        "/v1/repositories/apt/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository5Reader{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.(*GetRepository5OK)
	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 getRepository_5: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository6 gets repository
*/
func (a *Client) GetRepository6(params *GetRepository6Params, opts ...ClientOption) (*GetRepository6OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository6Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_6",
		Method:             "GET",
		PathPattern:        "/v1/repositories/raw/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository6Reader{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.(*GetRepository6OK)
	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 getRepository_6: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository7 gets repository
*/
func (a *Client) GetRepository7(params *GetRepository7Params, opts ...ClientOption) (*GetRepository7OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository7Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_7",
		Method:             "GET",
		PathPattern:        "/v1/repositories/raw/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository7Reader{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.(*GetRepository7OK)
	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 getRepository_7: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository8 gets repository
*/
func (a *Client) GetRepository8(params *GetRepository8Params, opts ...ClientOption) (*GetRepository8OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository8Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_8",
		Method:             "GET",
		PathPattern:        "/v1/repositories/raw/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository8Reader{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.(*GetRepository8OK)
	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 getRepository_8: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetRepository9 gets repository
*/
func (a *Client) GetRepository9(params *GetRepository9Params, opts ...ClientOption) (*GetRepository9OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRepository9Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "getRepository_9",
		Method:             "GET",
		PathPattern:        "/v1/repositories/npm/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetRepository9Reader{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.(*GetRepository9OK)
	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 getRepository_9: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
InvalidateCache invalidates repository cache proxy or group repositories only
*/
func (a *Client) InvalidateCache(params *InvalidateCacheParams, opts ...ClientOption) (*InvalidateCacheNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewInvalidateCacheParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "invalidateCache",
		Method:             "POST",
		PathPattern:        "/v1/repositories/{repositoryName}/invalidate-cache",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &InvalidateCacheReader{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.(*InvalidateCacheNoContent)
	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 invalidateCache: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
RebuildIndex schedules a repair rebuild repository search task hosted or proxy repositories only
*/
func (a *Client) RebuildIndex(params *RebuildIndexParams, opts ...ClientOption) (*RebuildIndexNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewRebuildIndexParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "rebuildIndex",
		Method:             "POST",
		PathPattern:        "/v1/repositories/{repositoryName}/rebuild-index",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &RebuildIndexReader{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.(*RebuildIndexNoContent)
	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 rebuildIndex: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository updates maven group repository
*/
func (a *Client) UpdateRepository(params *UpdateRepositoryParams, opts ...ClientOption) (*UpdateRepositoryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepositoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/maven/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepositoryReader{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.(*UpdateRepositoryNoContent)
	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 updateRepository: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository1 updates maven hosted repository
*/
func (a *Client) UpdateRepository1(params *UpdateRepository1Params, opts ...ClientOption) (*UpdateRepository1NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository1Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_1",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/maven/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository1Reader{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.(*UpdateRepository1NoContent)
	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 updateRepository_1: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository10 updates npm proxy repository
*/
func (a *Client) UpdateRepository10(params *UpdateRepository10Params, opts ...ClientOption) (*UpdateRepository10NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository10Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_10",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/npm/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository10Reader{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.(*UpdateRepository10NoContent)
	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 updateRepository_10: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository11 updates nu get group repository
*/
func (a *Client) UpdateRepository11(params *UpdateRepository11Params, opts ...ClientOption) (*UpdateRepository11NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository11Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_11",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/nuget/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository11Reader{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.(*UpdateRepository11NoContent)
	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 updateRepository_11: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository12 updates nu get hosted repository
*/
func (a *Client) UpdateRepository12(params *UpdateRepository12Params, opts ...ClientOption) (*UpdateRepository12NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository12Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_12",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/nuget/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository12Reader{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.(*UpdateRepository12NoContent)
	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 updateRepository_12: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository13 updates nu get proxy repository
*/
func (a *Client) UpdateRepository13(params *UpdateRepository13Params, opts ...ClientOption) (*UpdateRepository13NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository13Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_13",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/nuget/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository13Reader{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.(*UpdateRepository13NoContent)
	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 updateRepository_13: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository14 updates ruby gems group repository
*/
func (a *Client) UpdateRepository14(params *UpdateRepository14Params, opts ...ClientOption) (*UpdateRepository14NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository14Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_14",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/rubygems/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository14Reader{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.(*UpdateRepository14NoContent)
	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 updateRepository_14: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository15 updates ruby gems hosted repository
*/
func (a *Client) UpdateRepository15(params *UpdateRepository15Params, opts ...ClientOption) (*UpdateRepository15NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository15Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_15",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/rubygems/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository15Reader{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.(*UpdateRepository15NoContent)
	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 updateRepository_15: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository16 updates ruby gems proxy repository
*/
func (a *Client) UpdateRepository16(params *UpdateRepository16Params, opts ...ClientOption) (*UpdateRepository16NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository16Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_16",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/rubygems/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository16Reader{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.(*UpdateRepository16NoContent)
	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 updateRepository_16: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository17 updates docker group repository
*/
func (a *Client) UpdateRepository17(params *UpdateRepository17Params, opts ...ClientOption) (*UpdateRepository17NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository17Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_17",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/docker/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository17Reader{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.(*UpdateRepository17NoContent)
	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 updateRepository_17: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository18 updates docker hosted repository
*/
func (a *Client) UpdateRepository18(params *UpdateRepository18Params, opts ...ClientOption) (*UpdateRepository18NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository18Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_18",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/docker/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository18Reader{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.(*UpdateRepository18NoContent)
	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 updateRepository_18: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository19 updates docker group repository
*/
func (a *Client) UpdateRepository19(params *UpdateRepository19Params, opts ...ClientOption) (*UpdateRepository19NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository19Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_19",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/docker/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository19Reader{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.(*UpdateRepository19NoContent)
	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 updateRepository_19: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository2 updates maven proxy repository
*/
func (a *Client) UpdateRepository2(params *UpdateRepository2Params, opts ...ClientOption) (*UpdateRepository2NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository2Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_2",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/maven/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository2Reader{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.(*UpdateRepository2NoContent)
	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 updateRepository_2: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository20 updates yum group repository
*/
func (a *Client) UpdateRepository20(params *UpdateRepository20Params, opts ...ClientOption) (*UpdateRepository20NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository20Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_20",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/yum/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository20Reader{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.(*UpdateRepository20NoContent)
	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 updateRepository_20: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository21 updates yum hosted repository
*/
func (a *Client) UpdateRepository21(params *UpdateRepository21Params, opts ...ClientOption) (*UpdateRepository21NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository21Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_21",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/yum/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository21Reader{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.(*UpdateRepository21NoContent)
	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 updateRepository_21: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository22 updates yum proxy repository
*/
func (a *Client) UpdateRepository22(params *UpdateRepository22Params, opts ...ClientOption) (*UpdateRepository22NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository22Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_22",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/yum/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository22Reader{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.(*UpdateRepository22NoContent)
	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 updateRepository_22: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository23 updates helm hosted repository
*/
func (a *Client) UpdateRepository23(params *UpdateRepository23Params, opts ...ClientOption) (*UpdateRepository23NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository23Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_23",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/helm/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository23Reader{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.(*UpdateRepository23NoContent)
	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 updateRepository_23: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository24 updates helm proxy repository
*/
func (a *Client) UpdateRepository24(params *UpdateRepository24Params, opts ...ClientOption) (*UpdateRepository24NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository24Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_24",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/helm/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository24Reader{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.(*UpdateRepository24NoContent)
	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 updateRepository_24: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository25 updates git l f s hosted repository
*/
func (a *Client) UpdateRepository25(params *UpdateRepository25Params, opts ...ClientOption) (*UpdateRepository25NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository25Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_25",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/gitlfs/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository25Reader{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.(*UpdateRepository25NoContent)
	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 updateRepository_25: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository26 updates py p i group repository
*/
func (a *Client) UpdateRepository26(params *UpdateRepository26Params, opts ...ClientOption) (*UpdateRepository26NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository26Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_26",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/pypi/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository26Reader{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.(*UpdateRepository26NoContent)
	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 updateRepository_26: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository27 updates py p i hosted repository
*/
func (a *Client) UpdateRepository27(params *UpdateRepository27Params, opts ...ClientOption) (*UpdateRepository27NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository27Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_27",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/pypi/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository27Reader{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.(*UpdateRepository27NoContent)
	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 updateRepository_27: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository28 updates py p i proxy repository
*/
func (a *Client) UpdateRepository28(params *UpdateRepository28Params, opts ...ClientOption) (*UpdateRepository28NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository28Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_28",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/pypi/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository28Reader{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.(*UpdateRepository28NoContent)
	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 updateRepository_28: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository29 updates conda proxy repository
*/
func (a *Client) UpdateRepository29(params *UpdateRepository29Params, opts ...ClientOption) (*UpdateRepository29NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository29Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_29",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/conda/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository29Reader{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.(*UpdateRepository29NoContent)
	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 updateRepository_29: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository3 updates a p t hosted repository
*/
func (a *Client) UpdateRepository3(params *UpdateRepository3Params, opts ...ClientOption) (*UpdateRepository3NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository3Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_3",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/apt/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository3Reader{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.(*UpdateRepository3NoContent)
	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 updateRepository_3: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository30 updates conan proxy repository
*/
func (a *Client) UpdateRepository30(params *UpdateRepository30Params, opts ...ClientOption) (*UpdateRepository30NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository30Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_30",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/conan/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository30Reader{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.(*UpdateRepository30NoContent)
	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 updateRepository_30: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository31 updates r group repository
*/
func (a *Client) UpdateRepository31(params *UpdateRepository31Params, opts ...ClientOption) (*UpdateRepository31NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository31Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_31",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/r/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository31Reader{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.(*UpdateRepository31NoContent)
	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 updateRepository_31: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository32 updates r hosted repository
*/
func (a *Client) UpdateRepository32(params *UpdateRepository32Params, opts ...ClientOption) (*UpdateRepository32NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository32Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_32",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/r/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository32Reader{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.(*UpdateRepository32NoContent)
	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 updateRepository_32: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository33 updates r proxy repository
*/
func (a *Client) UpdateRepository33(params *UpdateRepository33Params, opts ...ClientOption) (*UpdateRepository33NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository33Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_33",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/r/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository33Reader{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.(*UpdateRepository33NoContent)
	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 updateRepository_33: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository34 updates cocoapods proxy repository
*/
func (a *Client) UpdateRepository34(params *UpdateRepository34Params, opts ...ClientOption) (*UpdateRepository34NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository34Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_34",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/cocoapods/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository34Reader{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.(*UpdateRepository34NoContent)
	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 updateRepository_34: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository35 updates a go group repository
*/
func (a *Client) UpdateRepository35(params *UpdateRepository35Params, opts ...ClientOption) (*UpdateRepository35NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository35Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_35",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/go/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository35Reader{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.(*UpdateRepository35NoContent)
	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 updateRepository_35: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository36 updates a go proxy repository
*/
func (a *Client) UpdateRepository36(params *UpdateRepository36Params, opts ...ClientOption) (*UpdateRepository36NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository36Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_36",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/go/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository36Reader{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.(*UpdateRepository36NoContent)
	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 updateRepository_36: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository37 updates p2 proxy repository
*/
func (a *Client) UpdateRepository37(params *UpdateRepository37Params, opts ...ClientOption) (*UpdateRepository37NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository37Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_37",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/p2/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository37Reader{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.(*UpdateRepository37NoContent)
	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 updateRepository_37: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository38 updates bower group repository
*/
func (a *Client) UpdateRepository38(params *UpdateRepository38Params, opts ...ClientOption) (*UpdateRepository38NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository38Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_38",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/bower/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository38Reader{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.(*UpdateRepository38NoContent)
	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 updateRepository_38: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository39 updates bower hosted repository
*/
func (a *Client) UpdateRepository39(params *UpdateRepository39Params, opts ...ClientOption) (*UpdateRepository39NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository39Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_39",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/bower/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository39Reader{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.(*UpdateRepository39NoContent)
	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 updateRepository_39: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository4 updates a p t proxy repository
*/
func (a *Client) UpdateRepository4(params *UpdateRepository4Params, opts ...ClientOption) (*UpdateRepository4NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository4Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_4",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/apt/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository4Reader{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.(*UpdateRepository4NoContent)
	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 updateRepository_4: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository40 updates bower proxy repository
*/
func (a *Client) UpdateRepository40(params *UpdateRepository40Params, opts ...ClientOption) (*UpdateRepository40NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository40Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_40",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/bower/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository40Reader{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.(*UpdateRepository40NoContent)
	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 updateRepository_40: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository5 updates raw group repository
*/
func (a *Client) UpdateRepository5(params *UpdateRepository5Params, opts ...ClientOption) (*UpdateRepository5NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository5Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_5",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/raw/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository5Reader{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.(*UpdateRepository5NoContent)
	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 updateRepository_5: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository6 updates raw hosted repository
*/
func (a *Client) UpdateRepository6(params *UpdateRepository6Params, opts ...ClientOption) (*UpdateRepository6NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository6Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_6",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/raw/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository6Reader{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.(*UpdateRepository6NoContent)
	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 updateRepository_6: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository7 updates raw proxy repository
*/
func (a *Client) UpdateRepository7(params *UpdateRepository7Params, opts ...ClientOption) (*UpdateRepository7NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository7Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_7",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/raw/proxy/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository7Reader{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.(*UpdateRepository7NoContent)
	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 updateRepository_7: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository8 updates npm group repository
*/
func (a *Client) UpdateRepository8(params *UpdateRepository8Params, opts ...ClientOption) (*UpdateRepository8NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository8Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_8",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/npm/group/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository8Reader{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.(*UpdateRepository8NoContent)
	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 updateRepository_8: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateRepository9 updates npm hosted repository
*/
func (a *Client) UpdateRepository9(params *UpdateRepository9Params, opts ...ClientOption) (*UpdateRepository9NoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRepository9Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateRepository_9",
		Method:             "PUT",
		PathPattern:        "/v1/repositories/npm/hosted/{repositoryName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateRepository9Reader{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.(*UpdateRepository9NoContent)
	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 updateRepository_9: 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
}
