model_registry_v1_client.go

// Copyright 2018-2021 Polyaxon, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

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

package model_registry_v1

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

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

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

/*
Client for model registry v1 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 {
	ArchiveModelRegistry(params *ArchiveModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ArchiveModelRegistryOK, *ArchiveModelRegistryNoContent, error)

	BookmarkModelRegistry(params *BookmarkModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*BookmarkModelRegistryOK, *BookmarkModelRegistryNoContent, error)

	CreateModelRegistry(params *CreateModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateModelRegistryOK, *CreateModelRegistryNoContent, error)

	CreateModelVersion(params *CreateModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateModelVersionOK, *CreateModelVersionNoContent, error)

	CreateModelVersionStage(params *CreateModelVersionStageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateModelVersionStageOK, *CreateModelVersionStageNoContent, error)

	DeleteModelRegistry(params *DeleteModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteModelRegistryOK, *DeleteModelRegistryNoContent, error)

	DeleteModelVersion(params *DeleteModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteModelVersionOK, *DeleteModelVersionNoContent, error)

	GetModelRegistry(params *GetModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelRegistryOK, *GetModelRegistryNoContent, error)

	GetModelRegistryActivities(params *GetModelRegistryActivitiesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelRegistryActivitiesOK, *GetModelRegistryActivitiesNoContent, error)

	GetModelRegistrySettings(params *GetModelRegistrySettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelRegistrySettingsOK, *GetModelRegistrySettingsNoContent, error)

	GetModelVersion(params *GetModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelVersionOK, *GetModelVersionNoContent, error)

	GetModelVersionStages(params *GetModelVersionStagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelVersionStagesOK, *GetModelVersionStagesNoContent, error)

	ListModelRegistries(params *ListModelRegistriesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelRegistriesOK, *ListModelRegistriesNoContent, error)

	ListModelRegistryNames(params *ListModelRegistryNamesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelRegistryNamesOK, *ListModelRegistryNamesNoContent, error)

	ListModelVersionNames(params *ListModelVersionNamesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelVersionNamesOK, *ListModelVersionNamesNoContent, error)

	ListModelVersions(params *ListModelVersionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelVersionsOK, *ListModelVersionsNoContent, error)

	PatchModelRegistry(params *PatchModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchModelRegistryOK, *PatchModelRegistryNoContent, error)

	PatchModelRegistrySettings(params *PatchModelRegistrySettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchModelRegistrySettingsOK, *PatchModelRegistrySettingsNoContent, error)

	PatchModelVersion(params *PatchModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchModelVersionOK, *PatchModelVersionNoContent, error)

	RestoreModelRegistry(params *RestoreModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RestoreModelRegistryOK, *RestoreModelRegistryNoContent, error)

	UnbookmarkModelRegistry(params *UnbookmarkModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UnbookmarkModelRegistryOK, *UnbookmarkModelRegistryNoContent, error)

	UpdateModelRegistry(params *UpdateModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateModelRegistryOK, *UpdateModelRegistryNoContent, error)

	UpdateModelRegistrySettings(params *UpdateModelRegistrySettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateModelRegistrySettingsOK, *UpdateModelRegistrySettingsNoContent, error)

	UpdateModelVersion(params *UpdateModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateModelVersionOK, *UpdateModelVersionNoContent, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  ArchiveModelRegistry archives registry model
*/
func (a *Client) ArchiveModelRegistry(params *ArchiveModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ArchiveModelRegistryOK, *ArchiveModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewArchiveModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ArchiveModelRegistry",
		Method:             "POST",
		PathPattern:        "/api/v1/{owner}/registry/{name}/archive",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ArchiveModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ArchiveModelRegistryOK:
		return value, nil, nil
	case *ArchiveModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ArchiveModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  BookmarkModelRegistry bookmarks registry model
*/
func (a *Client) BookmarkModelRegistry(params *BookmarkModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*BookmarkModelRegistryOK, *BookmarkModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewBookmarkModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "BookmarkModelRegistry",
		Method:             "POST",
		PathPattern:        "/api/v1/{owner}/registry/{name}/bookmark",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &BookmarkModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *BookmarkModelRegistryOK:
		return value, nil, nil
	case *BookmarkModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*BookmarkModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreateModelRegistry creates registry model
*/
func (a *Client) CreateModelRegistry(params *CreateModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateModelRegistryOK, *CreateModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateModelRegistry",
		Method:             "POST",
		PathPattern:        "/api/v1/{owner}/registry/create",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CreateModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *CreateModelRegistryOK:
		return value, nil, nil
	case *CreateModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreateModelVersion creates model version
*/
func (a *Client) CreateModelVersion(params *CreateModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateModelVersionOK, *CreateModelVersionNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateModelVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateModelVersion",
		Method:             "POST",
		PathPattern:        "/api/v1/{owner}/registry/{model}/versions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CreateModelVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *CreateModelVersionOK:
		return value, nil, nil
	case *CreateModelVersionNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateModelVersionDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreateModelVersionStage creates new model version stage
*/
func (a *Client) CreateModelVersionStage(params *CreateModelVersionStageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateModelVersionStageOK, *CreateModelVersionStageNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateModelVersionStageParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateModelVersionStage",
		Method:             "POST",
		PathPattern:        "/api/v1/{owner}/registry/{entity}/versions/{name}/stages",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CreateModelVersionStageReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *CreateModelVersionStageOK:
		return value, nil, nil
	case *CreateModelVersionStageNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateModelVersionStageDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  DeleteModelRegistry deletes registry model
*/
func (a *Client) DeleteModelRegistry(params *DeleteModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteModelRegistryOK, *DeleteModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteModelRegistry",
		Method:             "DELETE",
		PathPattern:        "/api/v1/{owner}/registry/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeleteModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *DeleteModelRegistryOK:
		return value, nil, nil
	case *DeleteModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  DeleteModelVersion deletes model version
*/
func (a *Client) DeleteModelVersion(params *DeleteModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteModelVersionOK, *DeleteModelVersionNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteModelVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteModelVersion",
		Method:             "DELETE",
		PathPattern:        "/api/v1/{owner}/registry/{entity}/versions/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeleteModelVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *DeleteModelVersionOK:
		return value, nil, nil
	case *DeleteModelVersionNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteModelVersionDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetModelRegistry gets registry model
*/
func (a *Client) GetModelRegistry(params *GetModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelRegistryOK, *GetModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetModelRegistry",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *GetModelRegistryOK:
		return value, nil, nil
	case *GetModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetModelRegistryActivities gets model activities
*/
func (a *Client) GetModelRegistryActivities(params *GetModelRegistryActivitiesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelRegistryActivitiesOK, *GetModelRegistryActivitiesNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetModelRegistryActivitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetModelRegistryActivities",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/{name}/activities",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetModelRegistryActivitiesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *GetModelRegistryActivitiesOK:
		return value, nil, nil
	case *GetModelRegistryActivitiesNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetModelRegistryActivitiesDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetModelRegistrySettings gets registry model settings
*/
func (a *Client) GetModelRegistrySettings(params *GetModelRegistrySettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelRegistrySettingsOK, *GetModelRegistrySettingsNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetModelRegistrySettingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetModelRegistrySettings",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/{name}/settings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetModelRegistrySettingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *GetModelRegistrySettingsOK:
		return value, nil, nil
	case *GetModelRegistrySettingsNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetModelRegistrySettingsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetModelVersion gets model version
*/
func (a *Client) GetModelVersion(params *GetModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelVersionOK, *GetModelVersionNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetModelVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetModelVersion",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/{entity}/versions/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetModelVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *GetModelVersionOK:
		return value, nil, nil
	case *GetModelVersionNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetModelVersionDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetModelVersionStages gets model version stages
*/
func (a *Client) GetModelVersionStages(params *GetModelVersionStagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetModelVersionStagesOK, *GetModelVersionStagesNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetModelVersionStagesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetModelVersionStages",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/{entity}/versions/{name}/stages",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetModelVersionStagesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *GetModelVersionStagesOK:
		return value, nil, nil
	case *GetModelVersionStagesNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetModelVersionStagesDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListModelRegistries lists registry models
*/
func (a *Client) ListModelRegistries(params *ListModelRegistriesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelRegistriesOK, *ListModelRegistriesNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListModelRegistriesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListModelRegistries",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/list",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ListModelRegistriesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ListModelRegistriesOK:
		return value, nil, nil
	case *ListModelRegistriesNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListModelRegistriesDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListModelRegistryNames lists registry model names
*/
func (a *Client) ListModelRegistryNames(params *ListModelRegistryNamesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelRegistryNamesOK, *ListModelRegistryNamesNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListModelRegistryNamesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListModelRegistryNames",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/names",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ListModelRegistryNamesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ListModelRegistryNamesOK:
		return value, nil, nil
	case *ListModelRegistryNamesNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListModelRegistryNamesDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListModelVersionNames lists model versions names
*/
func (a *Client) ListModelVersionNames(params *ListModelVersionNamesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelVersionNamesOK, *ListModelVersionNamesNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListModelVersionNamesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListModelVersionNames",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/{name}/versions/names",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ListModelVersionNamesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ListModelVersionNamesOK:
		return value, nil, nil
	case *ListModelVersionNamesNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListModelVersionNamesDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListModelVersions lists model versions
*/
func (a *Client) ListModelVersions(params *ListModelVersionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListModelVersionsOK, *ListModelVersionsNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListModelVersionsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListModelVersions",
		Method:             "GET",
		PathPattern:        "/api/v1/{owner}/registry/{name}/versions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ListModelVersionsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ListModelVersionsOK:
		return value, nil, nil
	case *ListModelVersionsNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListModelVersionsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  PatchModelRegistry patches registry model
*/
func (a *Client) PatchModelRegistry(params *PatchModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchModelRegistryOK, *PatchModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PatchModelRegistry",
		Method:             "PATCH",
		PathPattern:        "/api/v1/{owner}/registry/{model.name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &PatchModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *PatchModelRegistryOK:
		return value, nil, nil
	case *PatchModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*PatchModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  PatchModelRegistrySettings patches registry model settings
*/
func (a *Client) PatchModelRegistrySettings(params *PatchModelRegistrySettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchModelRegistrySettingsOK, *PatchModelRegistrySettingsNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchModelRegistrySettingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PatchModelRegistrySettings",
		Method:             "PATCH",
		PathPattern:        "/api/v1/{owner}/registry/{model}/settings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &PatchModelRegistrySettingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *PatchModelRegistrySettingsOK:
		return value, nil, nil
	case *PatchModelRegistrySettingsNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*PatchModelRegistrySettingsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  PatchModelVersion patches model version
*/
func (a *Client) PatchModelVersion(params *PatchModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchModelVersionOK, *PatchModelVersionNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchModelVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PatchModelVersion",
		Method:             "PATCH",
		PathPattern:        "/api/v1/{owner}/registry/{model}/versions/{version.name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &PatchModelVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *PatchModelVersionOK:
		return value, nil, nil
	case *PatchModelVersionNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*PatchModelVersionDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  RestoreModelRegistry restores registry model
*/
func (a *Client) RestoreModelRegistry(params *RestoreModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RestoreModelRegistryOK, *RestoreModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewRestoreModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "RestoreModelRegistry",
		Method:             "POST",
		PathPattern:        "/api/v1/{owner}/registry/{name}/restore",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &RestoreModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *RestoreModelRegistryOK:
		return value, nil, nil
	case *RestoreModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*RestoreModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  UnbookmarkModelRegistry unbookmarks registry model
*/
func (a *Client) UnbookmarkModelRegistry(params *UnbookmarkModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UnbookmarkModelRegistryOK, *UnbookmarkModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUnbookmarkModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UnbookmarkModelRegistry",
		Method:             "DELETE",
		PathPattern:        "/api/v1/{owner}/registry/{name}/unbookmark",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UnbookmarkModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *UnbookmarkModelRegistryOK:
		return value, nil, nil
	case *UnbookmarkModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UnbookmarkModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  UpdateModelRegistry updates registry model
*/
func (a *Client) UpdateModelRegistry(params *UpdateModelRegistryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateModelRegistryOK, *UpdateModelRegistryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateModelRegistryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateModelRegistry",
		Method:             "PUT",
		PathPattern:        "/api/v1/{owner}/registry/{model.name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UpdateModelRegistryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *UpdateModelRegistryOK:
		return value, nil, nil
	case *UpdateModelRegistryNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateModelRegistryDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  UpdateModelRegistrySettings updates registry model settings
*/
func (a *Client) UpdateModelRegistrySettings(params *UpdateModelRegistrySettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateModelRegistrySettingsOK, *UpdateModelRegistrySettingsNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateModelRegistrySettingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateModelRegistrySettings",
		Method:             "PUT",
		PathPattern:        "/api/v1/{owner}/registry/{model}/settings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UpdateModelRegistrySettingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *UpdateModelRegistrySettingsOK:
		return value, nil, nil
	case *UpdateModelRegistrySettingsNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateModelRegistrySettingsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  UpdateModelVersion updates model version
*/
func (a *Client) UpdateModelVersion(params *UpdateModelVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateModelVersionOK, *UpdateModelVersionNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateModelVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateModelVersion",
		Method:             "PUT",
		PathPattern:        "/api/v1/{owner}/registry/{model}/versions/{version.name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UpdateModelVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *UpdateModelVersionOK:
		return value, nil, nil
	case *UpdateModelVersionNoContent:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateModelVersionDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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