databricks-cli/cmd/workspace/model-registry/model-registry.go

// Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.

package model_registry

import (
	"fmt"

	"github.com/databricks/cli/cmd/root"
	"github.com/databricks/cli/libs/cmdio"
	"github.com/databricks/cli/libs/flags"
	"github.com/databricks/databricks-sdk-go/service/ml"
	"github.com/spf13/cobra"
)

var Cmd = &cobra.Command{
	Use:   "model-registry",
	Short: `MLflow Model Registry is a centralized model repository and a UI and set of APIs that enable you to manage the full lifecycle of MLflow Models.`,
	Long: `MLflow Model Registry is a centralized model repository and a UI and set of
  APIs that enable you to manage the full lifecycle of MLflow Models.`,
}

// start approve-transition-request command

var approveTransitionRequestReq ml.ApproveTransitionRequest
var approveTransitionRequestJson flags.JsonFlag

func init() {
	Cmd.AddCommand(approveTransitionRequestCmd)
	// TODO: short flags
	approveTransitionRequestCmd.Flags().Var(&approveTransitionRequestJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	approveTransitionRequestCmd.Flags().StringVar(&approveTransitionRequestReq.Comment, "comment", approveTransitionRequestReq.Comment, `User-provided comment on the action.`)

}

var approveTransitionRequestCmd = &cobra.Command{
	Use:   "approve-transition-request NAME VERSION STAGE ARCHIVE_EXISTING_VERSIONS",
	Short: `Approve transition request.`,
	Long: `Approve transition request.
  
  Approves a model version stage transition request.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(4)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = approveTransitionRequestJson.Unmarshal(&approveTransitionRequestReq)
			if err != nil {
				return err
			}
		} else {
			approveTransitionRequestReq.Name = args[0]
			approveTransitionRequestReq.Version = args[1]
			_, err = fmt.Sscan(args[2], &approveTransitionRequestReq.Stage)
			if err != nil {
				return fmt.Errorf("invalid STAGE: %s", args[2])
			}
			_, err = fmt.Sscan(args[3], &approveTransitionRequestReq.ArchiveExistingVersions)
			if err != nil {
				return fmt.Errorf("invalid ARCHIVE_EXISTING_VERSIONS: %s", args[3])
			}
		}

		response, err := w.ModelRegistry.ApproveTransitionRequest(ctx, approveTransitionRequestReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start create-comment command

var createCommentReq ml.CreateComment
var createCommentJson flags.JsonFlag

func init() {
	Cmd.AddCommand(createCommentCmd)
	// TODO: short flags
	createCommentCmd.Flags().Var(&createCommentJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var createCommentCmd = &cobra.Command{
	Use:   "create-comment NAME VERSION COMMENT",
	Short: `Post a comment.`,
	Long: `Post a comment.
  
  Posts a comment on a model version. A comment can be submitted either by a
  user or programmatically to display relevant information about the model. For
  example, test results or deployment errors.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(3)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = createCommentJson.Unmarshal(&createCommentReq)
			if err != nil {
				return err
			}
		} else {
			createCommentReq.Name = args[0]
			createCommentReq.Version = args[1]
			createCommentReq.Comment = args[2]
		}

		response, err := w.ModelRegistry.CreateComment(ctx, createCommentReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start create-model command

var createModelReq ml.CreateModelRequest
var createModelJson flags.JsonFlag

func init() {
	Cmd.AddCommand(createModelCmd)
	// TODO: short flags
	createModelCmd.Flags().Var(&createModelJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	createModelCmd.Flags().StringVar(&createModelReq.Description, "description", createModelReq.Description, `Optional description for registered model.`)
	// TODO: array: tags

}

var createModelCmd = &cobra.Command{
	Use:   "create-model NAME",
	Short: `Create a model.`,
	Long: `Create a model.
  
  Creates a new registered model with the name specified in the request body.
  
  Throws RESOURCE_ALREADY_EXISTS if a registered model with the given name
  exists.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = createModelJson.Unmarshal(&createModelReq)
			if err != nil {
				return err
			}
		} else {
			createModelReq.Name = args[0]
		}

		response, err := w.ModelRegistry.CreateModel(ctx, createModelReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start create-model-version command

var createModelVersionReq ml.CreateModelVersionRequest
var createModelVersionJson flags.JsonFlag

func init() {
	Cmd.AddCommand(createModelVersionCmd)
	// TODO: short flags
	createModelVersionCmd.Flags().Var(&createModelVersionJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	createModelVersionCmd.Flags().StringVar(&createModelVersionReq.Description, "description", createModelVersionReq.Description, `Optional description for model version.`)
	createModelVersionCmd.Flags().StringVar(&createModelVersionReq.RunId, "run-id", createModelVersionReq.RunId, `MLflow run ID for correlation, if source was generated by an experiment run in MLflow tracking server.`)
	createModelVersionCmd.Flags().StringVar(&createModelVersionReq.RunLink, "run-link", createModelVersionReq.RunLink, `MLflow run link - this is the exact link of the run that generated this model version, potentially hosted at another instance of MLflow.`)
	// TODO: array: tags

}

var createModelVersionCmd = &cobra.Command{
	Use:   "create-model-version NAME SOURCE",
	Short: `Create a model version.`,
	Long: `Create a model version.
  
  Creates a model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = createModelVersionJson.Unmarshal(&createModelVersionReq)
			if err != nil {
				return err
			}
		} else {
			createModelVersionReq.Name = args[0]
			createModelVersionReq.Source = args[1]
		}

		response, err := w.ModelRegistry.CreateModelVersion(ctx, createModelVersionReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start create-transition-request command

var createTransitionRequestReq ml.CreateTransitionRequest
var createTransitionRequestJson flags.JsonFlag

func init() {
	Cmd.AddCommand(createTransitionRequestCmd)
	// TODO: short flags
	createTransitionRequestCmd.Flags().Var(&createTransitionRequestJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	createTransitionRequestCmd.Flags().StringVar(&createTransitionRequestReq.Comment, "comment", createTransitionRequestReq.Comment, `User-provided comment on the action.`)

}

var createTransitionRequestCmd = &cobra.Command{
	Use:   "create-transition-request NAME VERSION STAGE",
	Short: `Make a transition request.`,
	Long: `Make a transition request.
  
  Creates a model version stage transition request.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(3)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = createTransitionRequestJson.Unmarshal(&createTransitionRequestReq)
			if err != nil {
				return err
			}
		} else {
			createTransitionRequestReq.Name = args[0]
			createTransitionRequestReq.Version = args[1]
			_, err = fmt.Sscan(args[2], &createTransitionRequestReq.Stage)
			if err != nil {
				return fmt.Errorf("invalid STAGE: %s", args[2])
			}
		}

		response, err := w.ModelRegistry.CreateTransitionRequest(ctx, createTransitionRequestReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start create-webhook command

var createWebhookReq ml.CreateRegistryWebhook
var createWebhookJson flags.JsonFlag

func init() {
	Cmd.AddCommand(createWebhookCmd)
	// TODO: short flags
	createWebhookCmd.Flags().Var(&createWebhookJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	createWebhookCmd.Flags().StringVar(&createWebhookReq.Description, "description", createWebhookReq.Description, `User-specified description for the webhook.`)
	// TODO: complex arg: http_url_spec
	// TODO: complex arg: job_spec
	createWebhookCmd.Flags().StringVar(&createWebhookReq.ModelName, "model-name", createWebhookReq.ModelName, `Name of the model whose events would trigger this webhook.`)
	createWebhookCmd.Flags().Var(&createWebhookReq.Status, "status", `This describes an enum.`)

}

var createWebhookCmd = &cobra.Command{
	Use:   "create-webhook",
	Short: `Create a webhook.`,
	Long: `Create a webhook.
  
  **NOTE**: This endpoint is in Public Preview.
  
  Creates a registry webhook.`,

	Annotations: map[string]string{},
	PreRunE:     root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = createWebhookJson.Unmarshal(&createWebhookReq)
			if err != nil {
				return err
			}
		} else {
			_, err = fmt.Sscan(args[0], &createWebhookReq.Events)
			if err != nil {
				return fmt.Errorf("invalid EVENTS: %s", args[0])
			}
		}

		response, err := w.ModelRegistry.CreateWebhook(ctx, createWebhookReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start delete-comment command

var deleteCommentReq ml.DeleteCommentRequest
var deleteCommentJson flags.JsonFlag

func init() {
	Cmd.AddCommand(deleteCommentCmd)
	// TODO: short flags
	deleteCommentCmd.Flags().Var(&deleteCommentJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var deleteCommentCmd = &cobra.Command{
	Use:   "delete-comment ID",
	Short: `Delete a comment.`,
	Long: `Delete a comment.
  
  Deletes a comment on a model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = deleteCommentJson.Unmarshal(&deleteCommentReq)
			if err != nil {
				return err
			}
		} else {
			deleteCommentReq.Id = args[0]
		}

		err = w.ModelRegistry.DeleteComment(ctx, deleteCommentReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start delete-model command

var deleteModelReq ml.DeleteModelRequest
var deleteModelJson flags.JsonFlag

func init() {
	Cmd.AddCommand(deleteModelCmd)
	// TODO: short flags
	deleteModelCmd.Flags().Var(&deleteModelJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var deleteModelCmd = &cobra.Command{
	Use:   "delete-model NAME",
	Short: `Delete a model.`,
	Long: `Delete a model.
  
  Deletes a registered model.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = deleteModelJson.Unmarshal(&deleteModelReq)
			if err != nil {
				return err
			}
		} else {
			deleteModelReq.Name = args[0]
		}

		err = w.ModelRegistry.DeleteModel(ctx, deleteModelReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start delete-model-tag command

var deleteModelTagReq ml.DeleteModelTagRequest
var deleteModelTagJson flags.JsonFlag

func init() {
	Cmd.AddCommand(deleteModelTagCmd)
	// TODO: short flags
	deleteModelTagCmd.Flags().Var(&deleteModelTagJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var deleteModelTagCmd = &cobra.Command{
	Use:   "delete-model-tag NAME KEY",
	Short: `Delete a model tag.`,
	Long: `Delete a model tag.
  
  Deletes the tag for a registered model.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = deleteModelTagJson.Unmarshal(&deleteModelTagReq)
			if err != nil {
				return err
			}
		} else {
			deleteModelTagReq.Name = args[0]
			deleteModelTagReq.Key = args[1]
		}

		err = w.ModelRegistry.DeleteModelTag(ctx, deleteModelTagReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start delete-model-version command

var deleteModelVersionReq ml.DeleteModelVersionRequest
var deleteModelVersionJson flags.JsonFlag

func init() {
	Cmd.AddCommand(deleteModelVersionCmd)
	// TODO: short flags
	deleteModelVersionCmd.Flags().Var(&deleteModelVersionJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var deleteModelVersionCmd = &cobra.Command{
	Use:   "delete-model-version NAME VERSION",
	Short: `Delete a model version.`,
	Long: `Delete a model version.
  
  Deletes a model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = deleteModelVersionJson.Unmarshal(&deleteModelVersionReq)
			if err != nil {
				return err
			}
		} else {
			deleteModelVersionReq.Name = args[0]
			deleteModelVersionReq.Version = args[1]
		}

		err = w.ModelRegistry.DeleteModelVersion(ctx, deleteModelVersionReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start delete-model-version-tag command

var deleteModelVersionTagReq ml.DeleteModelVersionTagRequest
var deleteModelVersionTagJson flags.JsonFlag

func init() {
	Cmd.AddCommand(deleteModelVersionTagCmd)
	// TODO: short flags
	deleteModelVersionTagCmd.Flags().Var(&deleteModelVersionTagJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var deleteModelVersionTagCmd = &cobra.Command{
	Use:   "delete-model-version-tag NAME VERSION KEY",
	Short: `Delete a model version tag.`,
	Long: `Delete a model version tag.
  
  Deletes a model version tag.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(3)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = deleteModelVersionTagJson.Unmarshal(&deleteModelVersionTagReq)
			if err != nil {
				return err
			}
		} else {
			deleteModelVersionTagReq.Name = args[0]
			deleteModelVersionTagReq.Version = args[1]
			deleteModelVersionTagReq.Key = args[2]
		}

		err = w.ModelRegistry.DeleteModelVersionTag(ctx, deleteModelVersionTagReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start delete-transition-request command

var deleteTransitionRequestReq ml.DeleteTransitionRequestRequest
var deleteTransitionRequestJson flags.JsonFlag

func init() {
	Cmd.AddCommand(deleteTransitionRequestCmd)
	// TODO: short flags
	deleteTransitionRequestCmd.Flags().Var(&deleteTransitionRequestJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	deleteTransitionRequestCmd.Flags().StringVar(&deleteTransitionRequestReq.Comment, "comment", deleteTransitionRequestReq.Comment, `User-provided comment on the action.`)

}

var deleteTransitionRequestCmd = &cobra.Command{
	Use:   "delete-transition-request NAME VERSION STAGE CREATOR",
	Short: `Delete a ransition request.`,
	Long: `Delete a ransition request.
  
  Cancels a model version stage transition request.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(4)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = deleteTransitionRequestJson.Unmarshal(&deleteTransitionRequestReq)
			if err != nil {
				return err
			}
		} else {
			deleteTransitionRequestReq.Name = args[0]
			deleteTransitionRequestReq.Version = args[1]
			_, err = fmt.Sscan(args[2], &deleteTransitionRequestReq.Stage)
			if err != nil {
				return fmt.Errorf("invalid STAGE: %s", args[2])
			}
			deleteTransitionRequestReq.Creator = args[3]
		}

		err = w.ModelRegistry.DeleteTransitionRequest(ctx, deleteTransitionRequestReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start delete-webhook command

var deleteWebhookReq ml.DeleteWebhookRequest
var deleteWebhookJson flags.JsonFlag

func init() {
	Cmd.AddCommand(deleteWebhookCmd)
	// TODO: short flags
	deleteWebhookCmd.Flags().Var(&deleteWebhookJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	deleteWebhookCmd.Flags().StringVar(&deleteWebhookReq.Id, "id", deleteWebhookReq.Id, `Webhook ID required to delete a registry webhook.`)

}

var deleteWebhookCmd = &cobra.Command{
	Use:   "delete-webhook",
	Short: `Delete a webhook.`,
	Long: `Delete a webhook.
  
  **NOTE:** This endpoint is in Public Preview.
  
  Deletes a registry webhook.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(0)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = deleteWebhookJson.Unmarshal(&deleteWebhookReq)
			if err != nil {
				return err
			}
		} else {
		}

		err = w.ModelRegistry.DeleteWebhook(ctx, deleteWebhookReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start get-latest-versions command

var getLatestVersionsReq ml.GetLatestVersionsRequest
var getLatestVersionsJson flags.JsonFlag

func init() {
	Cmd.AddCommand(getLatestVersionsCmd)
	// TODO: short flags
	getLatestVersionsCmd.Flags().Var(&getLatestVersionsJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	// TODO: array: stages

}

var getLatestVersionsCmd = &cobra.Command{
	Use:   "get-latest-versions NAME",
	Short: `Get the latest version.`,
	Long: `Get the latest version.
  
  Gets the latest version of a registered model.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = getLatestVersionsJson.Unmarshal(&getLatestVersionsReq)
			if err != nil {
				return err
			}
		} else {
			getLatestVersionsReq.Name = args[0]
		}

		response, err := w.ModelRegistry.GetLatestVersionsAll(ctx, getLatestVersionsReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start get-model command

var getModelReq ml.GetModelRequest
var getModelJson flags.JsonFlag

func init() {
	Cmd.AddCommand(getModelCmd)
	// TODO: short flags
	getModelCmd.Flags().Var(&getModelJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var getModelCmd = &cobra.Command{
	Use:   "get-model NAME",
	Short: `Get model.`,
	Long: `Get model.
  
  Get the details of a model. This is a Databricks workspace version of the
  [MLflow endpoint] that also returns the model's Databricks workspace ID and
  the permission level of the requesting user on the model.
  
  [MLflow endpoint]: https://www.mlflow.org/docs/latest/rest-api.html#get-registeredmodel`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = getModelJson.Unmarshal(&getModelReq)
			if err != nil {
				return err
			}
		} else {
			getModelReq.Name = args[0]
		}

		response, err := w.ModelRegistry.GetModel(ctx, getModelReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start get-model-version command

var getModelVersionReq ml.GetModelVersionRequest
var getModelVersionJson flags.JsonFlag

func init() {
	Cmd.AddCommand(getModelVersionCmd)
	// TODO: short flags
	getModelVersionCmd.Flags().Var(&getModelVersionJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var getModelVersionCmd = &cobra.Command{
	Use:   "get-model-version NAME VERSION",
	Short: `Get a model version.`,
	Long: `Get a model version.
  
  Get a model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = getModelVersionJson.Unmarshal(&getModelVersionReq)
			if err != nil {
				return err
			}
		} else {
			getModelVersionReq.Name = args[0]
			getModelVersionReq.Version = args[1]
		}

		response, err := w.ModelRegistry.GetModelVersion(ctx, getModelVersionReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start get-model-version-download-uri command

var getModelVersionDownloadUriReq ml.GetModelVersionDownloadUriRequest
var getModelVersionDownloadUriJson flags.JsonFlag

func init() {
	Cmd.AddCommand(getModelVersionDownloadUriCmd)
	// TODO: short flags
	getModelVersionDownloadUriCmd.Flags().Var(&getModelVersionDownloadUriJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var getModelVersionDownloadUriCmd = &cobra.Command{
	Use:   "get-model-version-download-uri NAME VERSION",
	Short: `Get a model version URI.`,
	Long: `Get a model version URI.
  
  Gets a URI to download the model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = getModelVersionDownloadUriJson.Unmarshal(&getModelVersionDownloadUriReq)
			if err != nil {
				return err
			}
		} else {
			getModelVersionDownloadUriReq.Name = args[0]
			getModelVersionDownloadUriReq.Version = args[1]
		}

		response, err := w.ModelRegistry.GetModelVersionDownloadUri(ctx, getModelVersionDownloadUriReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start list-models command

var listModelsReq ml.ListModelsRequest
var listModelsJson flags.JsonFlag

func init() {
	Cmd.AddCommand(listModelsCmd)
	// TODO: short flags
	listModelsCmd.Flags().Var(&listModelsJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	listModelsCmd.Flags().IntVar(&listModelsReq.MaxResults, "max-results", listModelsReq.MaxResults, `Maximum number of registered models desired.`)
	listModelsCmd.Flags().StringVar(&listModelsReq.PageToken, "page-token", listModelsReq.PageToken, `Pagination token to go to the next page based on a previous query.`)

}

var listModelsCmd = &cobra.Command{
	Use:   "list-models",
	Short: `List models.`,
	Long: `List models.
  
  Lists all available registered models, up to the limit specified in
  __max_results__.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(0)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = listModelsJson.Unmarshal(&listModelsReq)
			if err != nil {
				return err
			}
		} else {
		}

		response, err := w.ModelRegistry.ListModelsAll(ctx, listModelsReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start list-transition-requests command

var listTransitionRequestsReq ml.ListTransitionRequestsRequest
var listTransitionRequestsJson flags.JsonFlag

func init() {
	Cmd.AddCommand(listTransitionRequestsCmd)
	// TODO: short flags
	listTransitionRequestsCmd.Flags().Var(&listTransitionRequestsJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var listTransitionRequestsCmd = &cobra.Command{
	Use:   "list-transition-requests NAME VERSION",
	Short: `List transition requests.`,
	Long: `List transition requests.
  
  Gets a list of all open stage transition requests for the model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = listTransitionRequestsJson.Unmarshal(&listTransitionRequestsReq)
			if err != nil {
				return err
			}
		} else {
			listTransitionRequestsReq.Name = args[0]
			listTransitionRequestsReq.Version = args[1]
		}

		response, err := w.ModelRegistry.ListTransitionRequestsAll(ctx, listTransitionRequestsReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start list-webhooks command

var listWebhooksReq ml.ListWebhooksRequest
var listWebhooksJson flags.JsonFlag

func init() {
	Cmd.AddCommand(listWebhooksCmd)
	// TODO: short flags
	listWebhooksCmd.Flags().Var(&listWebhooksJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	// TODO: array: events
	listWebhooksCmd.Flags().StringVar(&listWebhooksReq.ModelName, "model-name", listWebhooksReq.ModelName, `If not specified, all webhooks associated with the specified events are listed, regardless of their associated model.`)
	listWebhooksCmd.Flags().StringVar(&listWebhooksReq.PageToken, "page-token", listWebhooksReq.PageToken, `Token indicating the page of artifact results to fetch.`)

}

var listWebhooksCmd = &cobra.Command{
	Use:   "list-webhooks",
	Short: `List registry webhooks.`,
	Long: `List registry webhooks.
  
  **NOTE:** This endpoint is in Public Preview.
  
  Lists all registry webhooks.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(0)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = listWebhooksJson.Unmarshal(&listWebhooksReq)
			if err != nil {
				return err
			}
		} else {
		}

		response, err := w.ModelRegistry.ListWebhooksAll(ctx, listWebhooksReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start reject-transition-request command

var rejectTransitionRequestReq ml.RejectTransitionRequest
var rejectTransitionRequestJson flags.JsonFlag

func init() {
	Cmd.AddCommand(rejectTransitionRequestCmd)
	// TODO: short flags
	rejectTransitionRequestCmd.Flags().Var(&rejectTransitionRequestJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	rejectTransitionRequestCmd.Flags().StringVar(&rejectTransitionRequestReq.Comment, "comment", rejectTransitionRequestReq.Comment, `User-provided comment on the action.`)

}

var rejectTransitionRequestCmd = &cobra.Command{
	Use:   "reject-transition-request NAME VERSION STAGE",
	Short: `Reject a transition request.`,
	Long: `Reject a transition request.
  
  Rejects a model version stage transition request.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(3)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = rejectTransitionRequestJson.Unmarshal(&rejectTransitionRequestReq)
			if err != nil {
				return err
			}
		} else {
			rejectTransitionRequestReq.Name = args[0]
			rejectTransitionRequestReq.Version = args[1]
			_, err = fmt.Sscan(args[2], &rejectTransitionRequestReq.Stage)
			if err != nil {
				return fmt.Errorf("invalid STAGE: %s", args[2])
			}
		}

		response, err := w.ModelRegistry.RejectTransitionRequest(ctx, rejectTransitionRequestReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start rename-model command

var renameModelReq ml.RenameModelRequest
var renameModelJson flags.JsonFlag

func init() {
	Cmd.AddCommand(renameModelCmd)
	// TODO: short flags
	renameModelCmd.Flags().Var(&renameModelJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	renameModelCmd.Flags().StringVar(&renameModelReq.NewName, "new-name", renameModelReq.NewName, `If provided, updates the name for this registered_model.`)

}

var renameModelCmd = &cobra.Command{
	Use:   "rename-model NAME",
	Short: `Rename a model.`,
	Long: `Rename a model.
  
  Renames a registered model.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = renameModelJson.Unmarshal(&renameModelReq)
			if err != nil {
				return err
			}
		} else {
			renameModelReq.Name = args[0]
		}

		response, err := w.ModelRegistry.RenameModel(ctx, renameModelReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start search-model-versions command

var searchModelVersionsReq ml.SearchModelVersionsRequest
var searchModelVersionsJson flags.JsonFlag

func init() {
	Cmd.AddCommand(searchModelVersionsCmd)
	// TODO: short flags
	searchModelVersionsCmd.Flags().Var(&searchModelVersionsJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	searchModelVersionsCmd.Flags().StringVar(&searchModelVersionsReq.Filter, "filter", searchModelVersionsReq.Filter, `String filter condition, like "name='my-model-name'".`)
	searchModelVersionsCmd.Flags().IntVar(&searchModelVersionsReq.MaxResults, "max-results", searchModelVersionsReq.MaxResults, `Maximum number of models desired.`)
	// TODO: array: order_by
	searchModelVersionsCmd.Flags().StringVar(&searchModelVersionsReq.PageToken, "page-token", searchModelVersionsReq.PageToken, `Pagination token to go to next page based on previous search query.`)

}

var searchModelVersionsCmd = &cobra.Command{
	Use:   "search-model-versions",
	Short: `Searches model versions.`,
	Long: `Searches model versions.
  
  Searches for specific model versions based on the supplied __filter__.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(0)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = searchModelVersionsJson.Unmarshal(&searchModelVersionsReq)
			if err != nil {
				return err
			}
		} else {
		}

		response, err := w.ModelRegistry.SearchModelVersionsAll(ctx, searchModelVersionsReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start search-models command

var searchModelsReq ml.SearchModelsRequest
var searchModelsJson flags.JsonFlag

func init() {
	Cmd.AddCommand(searchModelsCmd)
	// TODO: short flags
	searchModelsCmd.Flags().Var(&searchModelsJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	searchModelsCmd.Flags().StringVar(&searchModelsReq.Filter, "filter", searchModelsReq.Filter, `String filter condition, like "name LIKE 'my-model-name'".`)
	searchModelsCmd.Flags().IntVar(&searchModelsReq.MaxResults, "max-results", searchModelsReq.MaxResults, `Maximum number of models desired.`)
	// TODO: array: order_by
	searchModelsCmd.Flags().StringVar(&searchModelsReq.PageToken, "page-token", searchModelsReq.PageToken, `Pagination token to go to the next page based on a previous search query.`)

}

var searchModelsCmd = &cobra.Command{
	Use:   "search-models",
	Short: `Search models.`,
	Long: `Search models.
  
  Search for registered models based on the specified __filter__.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(0)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = searchModelsJson.Unmarshal(&searchModelsReq)
			if err != nil {
				return err
			}
		} else {
		}

		response, err := w.ModelRegistry.SearchModelsAll(ctx, searchModelsReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start set-model-tag command

var setModelTagReq ml.SetModelTagRequest
var setModelTagJson flags.JsonFlag

func init() {
	Cmd.AddCommand(setModelTagCmd)
	// TODO: short flags
	setModelTagCmd.Flags().Var(&setModelTagJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var setModelTagCmd = &cobra.Command{
	Use:   "set-model-tag NAME KEY VALUE",
	Short: `Set a tag.`,
	Long: `Set a tag.
  
  Sets a tag on a registered model.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(3)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = setModelTagJson.Unmarshal(&setModelTagReq)
			if err != nil {
				return err
			}
		} else {
			setModelTagReq.Name = args[0]
			setModelTagReq.Key = args[1]
			setModelTagReq.Value = args[2]
		}

		err = w.ModelRegistry.SetModelTag(ctx, setModelTagReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start set-model-version-tag command

var setModelVersionTagReq ml.SetModelVersionTagRequest
var setModelVersionTagJson flags.JsonFlag

func init() {
	Cmd.AddCommand(setModelVersionTagCmd)
	// TODO: short flags
	setModelVersionTagCmd.Flags().Var(&setModelVersionTagJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var setModelVersionTagCmd = &cobra.Command{
	Use:   "set-model-version-tag NAME VERSION KEY VALUE",
	Short: `Set a version tag.`,
	Long: `Set a version tag.
  
  Sets a model version tag.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(4)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = setModelVersionTagJson.Unmarshal(&setModelVersionTagReq)
			if err != nil {
				return err
			}
		} else {
			setModelVersionTagReq.Name = args[0]
			setModelVersionTagReq.Version = args[1]
			setModelVersionTagReq.Key = args[2]
			setModelVersionTagReq.Value = args[3]
		}

		err = w.ModelRegistry.SetModelVersionTag(ctx, setModelVersionTagReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start test-registry-webhook command

var testRegistryWebhookReq ml.TestRegistryWebhookRequest
var testRegistryWebhookJson flags.JsonFlag

func init() {
	Cmd.AddCommand(testRegistryWebhookCmd)
	// TODO: short flags
	testRegistryWebhookCmd.Flags().Var(&testRegistryWebhookJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	testRegistryWebhookCmd.Flags().Var(&testRegistryWebhookReq.Event, "event", `If event is specified, the test trigger uses the specified event.`)

}

var testRegistryWebhookCmd = &cobra.Command{
	Use:   "test-registry-webhook ID",
	Short: `Test a webhook.`,
	Long: `Test a webhook.
  
  **NOTE:** This endpoint is in Public Preview.
  
  Tests a registry webhook.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = testRegistryWebhookJson.Unmarshal(&testRegistryWebhookReq)
			if err != nil {
				return err
			}
		} else {
			testRegistryWebhookReq.Id = args[0]
		}

		response, err := w.ModelRegistry.TestRegistryWebhook(ctx, testRegistryWebhookReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start transition-stage command

var transitionStageReq ml.TransitionModelVersionStageDatabricks
var transitionStageJson flags.JsonFlag

func init() {
	Cmd.AddCommand(transitionStageCmd)
	// TODO: short flags
	transitionStageCmd.Flags().Var(&transitionStageJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	transitionStageCmd.Flags().StringVar(&transitionStageReq.Comment, "comment", transitionStageReq.Comment, `User-provided comment on the action.`)

}

var transitionStageCmd = &cobra.Command{
	Use:   "transition-stage NAME VERSION STAGE ARCHIVE_EXISTING_VERSIONS",
	Short: `Transition a stage.`,
	Long: `Transition a stage.
  
  Transition a model version's stage. This is a Databricks workspace version of
  the [MLflow endpoint] that also accepts a comment associated with the
  transition to be recorded.",
  
  [MLflow endpoint]: https://www.mlflow.org/docs/latest/rest-api.html#transition-modelversion-stage`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(4)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = transitionStageJson.Unmarshal(&transitionStageReq)
			if err != nil {
				return err
			}
		} else {
			transitionStageReq.Name = args[0]
			transitionStageReq.Version = args[1]
			_, err = fmt.Sscan(args[2], &transitionStageReq.Stage)
			if err != nil {
				return fmt.Errorf("invalid STAGE: %s", args[2])
			}
			_, err = fmt.Sscan(args[3], &transitionStageReq.ArchiveExistingVersions)
			if err != nil {
				return fmt.Errorf("invalid ARCHIVE_EXISTING_VERSIONS: %s", args[3])
			}
		}

		response, err := w.ModelRegistry.TransitionStage(ctx, transitionStageReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start update-comment command

var updateCommentReq ml.UpdateComment
var updateCommentJson flags.JsonFlag

func init() {
	Cmd.AddCommand(updateCommentCmd)
	// TODO: short flags
	updateCommentCmd.Flags().Var(&updateCommentJson, "json", `either inline JSON string or @path/to/file.json with request body`)

}

var updateCommentCmd = &cobra.Command{
	Use:   "update-comment ID COMMENT",
	Short: `Update a comment.`,
	Long: `Update a comment.
  
  Post an edit to a comment on a model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = updateCommentJson.Unmarshal(&updateCommentReq)
			if err != nil {
				return err
			}
		} else {
			updateCommentReq.Id = args[0]
			updateCommentReq.Comment = args[1]
		}

		response, err := w.ModelRegistry.UpdateComment(ctx, updateCommentReq)
		if err != nil {
			return err
		}
		return cmdio.Render(ctx, response)
	},
}

// start update-model command

var updateModelReq ml.UpdateModelRequest
var updateModelJson flags.JsonFlag

func init() {
	Cmd.AddCommand(updateModelCmd)
	// TODO: short flags
	updateModelCmd.Flags().Var(&updateModelJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	updateModelCmd.Flags().StringVar(&updateModelReq.Description, "description", updateModelReq.Description, `If provided, updates the description for this registered_model.`)

}

var updateModelCmd = &cobra.Command{
	Use:   "update-model NAME",
	Short: `Update model.`,
	Long: `Update model.
  
  Updates a registered model.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = updateModelJson.Unmarshal(&updateModelReq)
			if err != nil {
				return err
			}
		} else {
			updateModelReq.Name = args[0]
		}

		err = w.ModelRegistry.UpdateModel(ctx, updateModelReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start update-model-version command

var updateModelVersionReq ml.UpdateModelVersionRequest
var updateModelVersionJson flags.JsonFlag

func init() {
	Cmd.AddCommand(updateModelVersionCmd)
	// TODO: short flags
	updateModelVersionCmd.Flags().Var(&updateModelVersionJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	updateModelVersionCmd.Flags().StringVar(&updateModelVersionReq.Description, "description", updateModelVersionReq.Description, `If provided, updates the description for this registered_model.`)

}

var updateModelVersionCmd = &cobra.Command{
	Use:   "update-model-version NAME VERSION",
	Short: `Update model version.`,
	Long: `Update model version.
  
  Updates the model version.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(2)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = updateModelVersionJson.Unmarshal(&updateModelVersionReq)
			if err != nil {
				return err
			}
		} else {
			updateModelVersionReq.Name = args[0]
			updateModelVersionReq.Version = args[1]
		}

		err = w.ModelRegistry.UpdateModelVersion(ctx, updateModelVersionReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// start update-webhook command

var updateWebhookReq ml.UpdateRegistryWebhook
var updateWebhookJson flags.JsonFlag

func init() {
	Cmd.AddCommand(updateWebhookCmd)
	// TODO: short flags
	updateWebhookCmd.Flags().Var(&updateWebhookJson, "json", `either inline JSON string or @path/to/file.json with request body`)

	updateWebhookCmd.Flags().StringVar(&updateWebhookReq.Description, "description", updateWebhookReq.Description, `User-specified description for the webhook.`)
	// TODO: array: events
	// TODO: complex arg: http_url_spec
	// TODO: complex arg: job_spec
	updateWebhookCmd.Flags().Var(&updateWebhookReq.Status, "status", `This describes an enum.`)

}

var updateWebhookCmd = &cobra.Command{
	Use:   "update-webhook ID",
	Short: `Update a webhook.`,
	Long: `Update a webhook.
  
  **NOTE:** This endpoint is in Public Preview.
  
  Updates a registry webhook.`,

	Annotations: map[string]string{},
	Args: func(cmd *cobra.Command, args []string) error {
		check := cobra.ExactArgs(1)
		if cmd.Flags().Changed("json") {
			check = cobra.ExactArgs(0)
		}
		return check(cmd, args)
	},
	PreRunE: root.MustWorkspaceClient,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		ctx := cmd.Context()
		w := root.WorkspaceClient(ctx)
		if cmd.Flags().Changed("json") {
			err = updateWebhookJson.Unmarshal(&updateWebhookReq)
			if err != nil {
				return err
			}
		} else {
			updateWebhookReq.Id = args[0]
		}

		err = w.ModelRegistry.UpdateWebhook(ctx, updateWebhookReq)
		if err != nil {
			return err
		}
		return nil
	},
}

// end service ModelRegistry