generated

var AdminClient *gapic.AdminClient

var AdminServiceCmd = &cobra.Command{
	Use:       "admin",
	Short:     "The Admin service supports setup and operation of...",
	Long:      "The Admin service supports setup and operation of an API registry.  It is typically not included in hosted versions of the API.",
	ValidArgs: AdminSubCommands,
	PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) {
		AdminClient, err = connection.NewAdminClient(ctx)
		return
	},
}

var AdminSubCommands []string = []string{
	"get-status",
	"get-storage",
	"migrate-database",
	"poll-migrate-database", "list-projects",
	"get-project",
	"create-project",
	"update-project",
	"delete-project",
}

var CreateApiCmd = &cobra.Command{
	Use:   "create-api",
	Short: "CreateApi creates a specified API.",
	Long:  "CreateApi creates a specified API.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if CreateApiFromFile == "" {

			cmd.MarkFlagRequired("parent")

			cmd.MarkFlagRequired("api_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if CreateApiFromFile != "" {
			in, err = os.Open(CreateApiFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &CreateApiInput)
			if err != nil {
				return err
			}

		}

		if len(CreateApiInputApiLabels) > 0 {
			CreateApiInput.Api.Labels = make(map[string]string)
		}
		for _, item := range CreateApiInputApiLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiInput.Api.Labels[split[0]] = split[1]
		}

		if len(CreateApiInputApiAnnotations) > 0 {
			CreateApiInput.Api.Annotations = make(map[string]string)
		}
		for _, item := range CreateApiInputApiAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiInput.Api.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "CreateApi", &CreateApiInput)
		}
		resp, err := RegistryClient.CreateApi(ctx, &CreateApiInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var CreateApiDeploymentCmd = &cobra.Command{
	Use:   "create-api-deployment",
	Short: "CreateApiDeployment creates a specified...",
	Long:  "CreateApiDeployment creates a specified deployment.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if CreateApiDeploymentFromFile == "" {

			cmd.MarkFlagRequired("parent")

			cmd.MarkFlagRequired("api_deployment_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if CreateApiDeploymentFromFile != "" {
			in, err = os.Open(CreateApiDeploymentFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &CreateApiDeploymentInput)
			if err != nil {
				return err
			}

		}

		if len(CreateApiDeploymentInputApiDeploymentLabels) > 0 {
			CreateApiDeploymentInput.ApiDeployment.Labels = make(map[string]string)
		}
		for _, item := range CreateApiDeploymentInputApiDeploymentLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiDeploymentInput.ApiDeployment.Labels[split[0]] = split[1]
		}

		if len(CreateApiDeploymentInputApiDeploymentAnnotations) > 0 {
			CreateApiDeploymentInput.ApiDeployment.Annotations = make(map[string]string)
		}
		for _, item := range CreateApiDeploymentInputApiDeploymentAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiDeploymentInput.ApiDeployment.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "CreateApiDeployment", &CreateApiDeploymentInput)
		}
		resp, err := RegistryClient.CreateApiDeployment(ctx, &CreateApiDeploymentInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var CreateApiDeploymentFromFile string

var CreateApiDeploymentInput rpcpb.CreateApiDeploymentRequest

var CreateApiDeploymentInputApiDeploymentAnnotations []string

var CreateApiDeploymentInputApiDeploymentLabels []string

var CreateApiFromFile string

var CreateApiInput rpcpb.CreateApiRequest

var CreateApiInputApiAnnotations []string

var CreateApiInputApiLabels []string

var CreateApiSpecCmd = &cobra.Command{
	Use:   "create-api-spec",
	Short: "CreateApiSpec creates a specified spec.",
	Long:  "CreateApiSpec creates a specified spec.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if CreateApiSpecFromFile == "" {

			cmd.MarkFlagRequired("parent")

			cmd.MarkFlagRequired("api_spec_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if CreateApiSpecFromFile != "" {
			in, err = os.Open(CreateApiSpecFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &CreateApiSpecInput)
			if err != nil {
				return err
			}

		}

		if len(CreateApiSpecInputApiSpecLabels) > 0 {
			CreateApiSpecInput.ApiSpec.Labels = make(map[string]string)
		}
		for _, item := range CreateApiSpecInputApiSpecLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiSpecInput.ApiSpec.Labels[split[0]] = split[1]
		}

		if len(CreateApiSpecInputApiSpecAnnotations) > 0 {
			CreateApiSpecInput.ApiSpec.Annotations = make(map[string]string)
		}
		for _, item := range CreateApiSpecInputApiSpecAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiSpecInput.ApiSpec.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "CreateApiSpec", &CreateApiSpecInput)
		}
		resp, err := RegistryClient.CreateApiSpec(ctx, &CreateApiSpecInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var CreateApiSpecFromFile string

var CreateApiSpecInput rpcpb.CreateApiSpecRequest

var CreateApiSpecInputApiSpecAnnotations []string

var CreateApiSpecInputApiSpecLabels []string

var CreateApiVersionCmd = &cobra.Command{
	Use:   "create-api-version",
	Short: "CreateApiVersion creates a specified version.",
	Long:  "CreateApiVersion creates a specified version.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if CreateApiVersionFromFile == "" {

			cmd.MarkFlagRequired("parent")

			cmd.MarkFlagRequired("api_version_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if CreateApiVersionFromFile != "" {
			in, err = os.Open(CreateApiVersionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &CreateApiVersionInput)
			if err != nil {
				return err
			}

		}

		if len(CreateApiVersionInputApiVersionLabels) > 0 {
			CreateApiVersionInput.ApiVersion.Labels = make(map[string]string)
		}
		for _, item := range CreateApiVersionInputApiVersionLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiVersionInput.ApiVersion.Labels[split[0]] = split[1]
		}

		if len(CreateApiVersionInputApiVersionAnnotations) > 0 {
			CreateApiVersionInput.ApiVersion.Annotations = make(map[string]string)
		}
		for _, item := range CreateApiVersionInputApiVersionAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateApiVersionInput.ApiVersion.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "CreateApiVersion", &CreateApiVersionInput)
		}
		resp, err := RegistryClient.CreateApiVersion(ctx, &CreateApiVersionInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var CreateApiVersionFromFile string

var CreateApiVersionInput rpcpb.CreateApiVersionRequest

var CreateApiVersionInputApiVersionAnnotations []string

var CreateApiVersionInputApiVersionLabels []string

var CreateArtifactCmd = &cobra.Command{
	Use:   "create-artifact",
	Short: "CreateArtifact creates a specified artifact.",
	Long:  "CreateArtifact creates a specified artifact.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if CreateArtifactFromFile == "" {

			cmd.MarkFlagRequired("parent")

			cmd.MarkFlagRequired("artifact_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if CreateArtifactFromFile != "" {
			in, err = os.Open(CreateArtifactFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &CreateArtifactInput)
			if err != nil {
				return err
			}

		}

		if len(CreateArtifactInputArtifactLabels) > 0 {
			CreateArtifactInput.Artifact.Labels = make(map[string]string)
		}
		for _, item := range CreateArtifactInputArtifactLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateArtifactInput.Artifact.Labels[split[0]] = split[1]
		}

		if len(CreateArtifactInputArtifactAnnotations) > 0 {
			CreateArtifactInput.Artifact.Annotations = make(map[string]string)
		}
		for _, item := range CreateArtifactInputArtifactAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			CreateArtifactInput.Artifact.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "CreateArtifact", &CreateArtifactInput)
		}
		resp, err := RegistryClient.CreateArtifact(ctx, &CreateArtifactInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var CreateArtifactFromFile string

var CreateArtifactInput rpcpb.CreateArtifactRequest

var CreateArtifactInputArtifactAnnotations []string

var CreateArtifactInputArtifactLabels []string

var CreateInstanceCmd = &cobra.Command{
	Use:   "create-instance",
	Short: "Provisions instance resources for the Registry.",
	Long:  "Provisions instance resources for the Registry.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if CreateInstanceFromFile == "" {

			cmd.MarkFlagRequired("parent")

			cmd.MarkFlagRequired("instance_id")

			cmd.MarkFlagRequired("instance.config.cmek_key_name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if CreateInstanceFromFile != "" {
			in, err = os.Open(CreateInstanceFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &CreateInstanceInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Provisioning", "CreateInstance", &CreateInstanceInput)
		}
		resp, err := ProvisioningClient.CreateInstance(ctx, &CreateInstanceInput)
		if err != nil {
			return err
		}

		if !CreateInstanceFollow {
			var s interface{}
			s = resp.Name()

			if OutputJSON {
				d := make(map[string]string)
				d["operation"] = resp.Name()
				s = d
			}

			printMessage(s)
			return err
		}

		result, err := resp.Wait(ctx)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(result)

		return err
	},
}

var CreateInstanceFollow bool

var CreateInstanceFromFile string

var CreateInstanceInput rpcpb.CreateInstanceRequest

var CreateInstancePollCmd = &cobra.Command{
	Use:   "poll-create-instance",
	Short: "Poll the status of a CreateInstanceOperation by name",
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		op := ProvisioningClient.CreateInstanceOperation(CreateInstancePollOperation)

		if CreateInstanceFollow {
			resp, err := op.Wait(ctx)
			if err != nil {
				return err
			}

			if Verbose {
				fmt.Print("Output: ")
			}
			printMessage(resp)
			return err
		}

		resp, err := op.Poll(ctx)
		if err != nil {
			return err
		} else if resp != nil {
			if Verbose {
				fmt.Print("Output: ")
			}

			printMessage(resp)
			return
		}

		if op.Done() {
			fmt.Println(fmt.Sprintf("Operation %s is done", op.Name()))
		} else {
			fmt.Println(fmt.Sprintf("Operation %s not done", op.Name()))
		}

		return err
	},
}

var CreateInstancePollOperation string

var CreateProjectCmd = &cobra.Command{
	Use:   "create-project",
	Short: "CreateProject creates a specified project.  (--...",
	Long:  "CreateProject creates a specified project.  (-- api-linter: standard-methods=disabled --)  (-- api-linter: core::0133::http-uri-parent=disabled     ...",
	PreRun: func(cmd *cobra.Command, args []string) {

		if CreateProjectFromFile == "" {

			cmd.MarkFlagRequired("project_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if CreateProjectFromFile != "" {
			in, err = os.Open(CreateProjectFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &CreateProjectInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Admin", "CreateProject", &CreateProjectInput)
		}
		resp, err := AdminClient.CreateProject(ctx, &CreateProjectInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var CreateProjectFromFile string

var CreateProjectInput rpcpb.CreateProjectRequest

var DeleteApiCmd = &cobra.Command{
	Use:   "delete-api",
	Short: "DeleteApi removes a specified API and all of the...",
	Long:  "DeleteApi removes a specified API and all of the resources that it  owns.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteApiFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteApiFromFile != "" {
			in, err = os.Open(DeleteApiFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteApiInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "DeleteApi", &DeleteApiInput)
		}
		err = RegistryClient.DeleteApi(ctx, &DeleteApiInput)
		if err != nil {
			return err
		}

		return err
	},
}

var DeleteApiDeploymentCmd = &cobra.Command{
	Use:   "delete-api-deployment",
	Short: "DeleteApiDeployment removes a specified...",
	Long:  "DeleteApiDeployment removes a specified deployment, all revisions, and all  child resources (e.g. artifacts).",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteApiDeploymentFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteApiDeploymentFromFile != "" {
			in, err = os.Open(DeleteApiDeploymentFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteApiDeploymentInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "DeleteApiDeployment", &DeleteApiDeploymentInput)
		}
		err = RegistryClient.DeleteApiDeployment(ctx, &DeleteApiDeploymentInput)
		if err != nil {
			return err
		}

		return err
	},
}

var DeleteApiDeploymentFromFile string

var DeleteApiDeploymentInput rpcpb.DeleteApiDeploymentRequest

var DeleteApiDeploymentRevisionCmd = &cobra.Command{
	Use:   "delete-api-deployment-revision",
	Short: "DeleteApiDeploymentRevision deletes a revision of...",
	Long:  "DeleteApiDeploymentRevision deletes a revision of a deployment.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteApiDeploymentRevisionFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteApiDeploymentRevisionFromFile != "" {
			in, err = os.Open(DeleteApiDeploymentRevisionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteApiDeploymentRevisionInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "DeleteApiDeploymentRevision", &DeleteApiDeploymentRevisionInput)
		}
		resp, err := RegistryClient.DeleteApiDeploymentRevision(ctx, &DeleteApiDeploymentRevisionInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var DeleteApiDeploymentRevisionFromFile string

var DeleteApiDeploymentRevisionInput rpcpb.DeleteApiDeploymentRevisionRequest

var DeleteApiFromFile string

var DeleteApiInput rpcpb.DeleteApiRequest

var DeleteApiSpecCmd = &cobra.Command{
	Use:   "delete-api-spec",
	Short: "DeleteApiSpec removes a specified spec, all...",
	Long:  "DeleteApiSpec removes a specified spec, all revisions, and all child  resources (e.g. artifacts).",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteApiSpecFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteApiSpecFromFile != "" {
			in, err = os.Open(DeleteApiSpecFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteApiSpecInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "DeleteApiSpec", &DeleteApiSpecInput)
		}
		err = RegistryClient.DeleteApiSpec(ctx, &DeleteApiSpecInput)
		if err != nil {
			return err
		}

		return err
	},
}

var DeleteApiSpecFromFile string

var DeleteApiSpecInput rpcpb.DeleteApiSpecRequest

var DeleteApiSpecRevisionCmd = &cobra.Command{
	Use:   "delete-api-spec-revision",
	Short: "DeleteApiSpecRevision deletes a revision of a...",
	Long:  "DeleteApiSpecRevision deletes a revision of a spec.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteApiSpecRevisionFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteApiSpecRevisionFromFile != "" {
			in, err = os.Open(DeleteApiSpecRevisionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteApiSpecRevisionInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "DeleteApiSpecRevision", &DeleteApiSpecRevisionInput)
		}
		resp, err := RegistryClient.DeleteApiSpecRevision(ctx, &DeleteApiSpecRevisionInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var DeleteApiSpecRevisionFromFile string

var DeleteApiSpecRevisionInput rpcpb.DeleteApiSpecRevisionRequest

var DeleteApiVersionCmd = &cobra.Command{
	Use:   "delete-api-version",
	Short: "DeleteApiVersion removes a specified version and...",
	Long:  "DeleteApiVersion removes a specified version and all of the resources that  it owns.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteApiVersionFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteApiVersionFromFile != "" {
			in, err = os.Open(DeleteApiVersionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteApiVersionInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "DeleteApiVersion", &DeleteApiVersionInput)
		}
		err = RegistryClient.DeleteApiVersion(ctx, &DeleteApiVersionInput)
		if err != nil {
			return err
		}

		return err
	},
}

var DeleteApiVersionFromFile string

var DeleteApiVersionInput rpcpb.DeleteApiVersionRequest

var DeleteArtifactCmd = &cobra.Command{
	Use:   "delete-artifact",
	Short: "DeleteArtifact removes a specified artifact.",
	Long:  "DeleteArtifact removes a specified artifact.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteArtifactFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteArtifactFromFile != "" {
			in, err = os.Open(DeleteArtifactFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteArtifactInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "DeleteArtifact", &DeleteArtifactInput)
		}
		err = RegistryClient.DeleteArtifact(ctx, &DeleteArtifactInput)
		if err != nil {
			return err
		}

		return err
	},
}

var DeleteArtifactFromFile string

var DeleteArtifactInput rpcpb.DeleteArtifactRequest

var DeleteInstanceCmd = &cobra.Command{
	Use:   "delete-instance",
	Short: "Deletes the Registry instance.",
	Long:  "Deletes the Registry instance.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteInstanceFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteInstanceFromFile != "" {
			in, err = os.Open(DeleteInstanceFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteInstanceInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Provisioning", "DeleteInstance", &DeleteInstanceInput)
		}
		resp, err := ProvisioningClient.DeleteInstance(ctx, &DeleteInstanceInput)
		if err != nil {
			return err
		}

		if !DeleteInstanceFollow {
			var s interface{}
			s = resp.Name()

			if OutputJSON {
				d := make(map[string]string)
				d["operation"] = resp.Name()
				s = d
			}

			printMessage(s)
			return err
		}

		err = resp.Wait(ctx)

		return err
	},
}

var DeleteInstanceFollow bool

var DeleteInstanceFromFile string

var DeleteInstanceInput rpcpb.DeleteInstanceRequest

var DeleteInstancePollCmd = &cobra.Command{
	Use:   "poll-delete-instance",
	Short: "Poll the status of a DeleteInstanceOperation by name",
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		op := ProvisioningClient.DeleteInstanceOperation(DeleteInstancePollOperation)

		if DeleteInstanceFollow {
			return op.Wait(ctx)
		}

		err = op.Poll(ctx)
		if err != nil {
			return err
		}

		if op.Done() {
			fmt.Println(fmt.Sprintf("Operation %s is done", op.Name()))
		} else {
			fmt.Println(fmt.Sprintf("Operation %s not done", op.Name()))
		}

		return err
	},
}

var DeleteInstancePollOperation string

var DeleteProjectCmd = &cobra.Command{
	Use:   "delete-project",
	Short: "DeleteProject removes a specified project and all...",
	Long:  "DeleteProject removes a specified project and all of the resources that it  owns.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if DeleteProjectFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if DeleteProjectFromFile != "" {
			in, err = os.Open(DeleteProjectFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &DeleteProjectInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Admin", "DeleteProject", &DeleteProjectInput)
		}
		err = AdminClient.DeleteProject(ctx, &DeleteProjectInput)
		if err != nil {
			return err
		}

		return err
	},
}

var DeleteProjectFromFile string

var DeleteProjectInput rpcpb.DeleteProjectRequest

var GetApiCmd = &cobra.Command{
	Use:   "get-api",
	Short: "GetApi returns a specified API.",
	Long:  "GetApi returns a specified API.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetApiFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetApiFromFile != "" {
			in, err = os.Open(GetApiFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetApiInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "GetApi", &GetApiInput)
		}
		resp, err := RegistryClient.GetApi(ctx, &GetApiInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetApiDeploymentCmd = &cobra.Command{
	Use:   "get-api-deployment",
	Short: "GetApiDeployment returns a specified deployment.",
	Long:  "GetApiDeployment returns a specified deployment.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetApiDeploymentFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetApiDeploymentFromFile != "" {
			in, err = os.Open(GetApiDeploymentFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetApiDeploymentInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "GetApiDeployment", &GetApiDeploymentInput)
		}
		resp, err := RegistryClient.GetApiDeployment(ctx, &GetApiDeploymentInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetApiDeploymentFromFile string

var GetApiDeploymentInput rpcpb.GetApiDeploymentRequest

var GetApiFromFile string

var GetApiInput rpcpb.GetApiRequest

var GetApiSpecCmd = &cobra.Command{
	Use:   "get-api-spec",
	Short: "GetApiSpec returns a specified spec.",
	Long:  "GetApiSpec returns a specified spec.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetApiSpecFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetApiSpecFromFile != "" {
			in, err = os.Open(GetApiSpecFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetApiSpecInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "GetApiSpec", &GetApiSpecInput)
		}
		resp, err := RegistryClient.GetApiSpec(ctx, &GetApiSpecInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetApiSpecContentsCmd = &cobra.Command{
	Use:   "get-api-spec-contents",
	Short: "GetApiSpecContents returns the contents of a...",
	Long:  "GetApiSpecContents returns the contents of a specified spec.  If specs are stored with GZip compression, the default behavior  is to return the spec...",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetApiSpecContentsFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetApiSpecContentsFromFile != "" {
			in, err = os.Open(GetApiSpecContentsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetApiSpecContentsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "GetApiSpecContents", &GetApiSpecContentsInput)
		}
		resp, err := RegistryClient.GetApiSpecContents(ctx, &GetApiSpecContentsInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetApiSpecContentsFromFile string

var GetApiSpecContentsInput rpcpb.GetApiSpecContentsRequest

var GetApiSpecFromFile string

var GetApiSpecInput rpcpb.GetApiSpecRequest

var GetApiVersionCmd = &cobra.Command{
	Use:   "get-api-version",
	Short: "GetApiVersion returns a specified version.",
	Long:  "GetApiVersion returns a specified version.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetApiVersionFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetApiVersionFromFile != "" {
			in, err = os.Open(GetApiVersionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetApiVersionInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "GetApiVersion", &GetApiVersionInput)
		}
		resp, err := RegistryClient.GetApiVersion(ctx, &GetApiVersionInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetApiVersionFromFile string

var GetApiVersionInput rpcpb.GetApiVersionRequest

var GetArtifactCmd = &cobra.Command{
	Use:   "get-artifact",
	Short: "GetArtifact returns a specified artifact.",
	Long:  "GetArtifact returns a specified artifact.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetArtifactFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetArtifactFromFile != "" {
			in, err = os.Open(GetArtifactFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetArtifactInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "GetArtifact", &GetArtifactInput)
		}
		resp, err := RegistryClient.GetArtifact(ctx, &GetArtifactInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetArtifactContentsCmd = &cobra.Command{
	Use:   "get-artifact-contents",
	Short: "GetArtifactContents returns the contents of a...",
	Long:  "GetArtifactContents returns the contents of a specified artifact.  If artifacts are stored with GZip compression, the default behavior  is to return...",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetArtifactContentsFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetArtifactContentsFromFile != "" {
			in, err = os.Open(GetArtifactContentsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetArtifactContentsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "GetArtifactContents", &GetArtifactContentsInput)
		}
		resp, err := RegistryClient.GetArtifactContents(ctx, &GetArtifactContentsInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetArtifactContentsFromFile string

var GetArtifactContentsInput rpcpb.GetArtifactContentsRequest

var GetArtifactFromFile string

var GetArtifactInput rpcpb.GetArtifactRequest

var GetInstanceCmd = &cobra.Command{
	Use:   "get-instance",
	Short: "Gets details of a single Instance.",
	Long:  "Gets details of a single Instance.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetInstanceFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetInstanceFromFile != "" {
			in, err = os.Open(GetInstanceFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetInstanceInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Provisioning", "GetInstance", &GetInstanceInput)
		}
		resp, err := ProvisioningClient.GetInstance(ctx, &GetInstanceInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetInstanceFromFile string

var GetInstanceInput rpcpb.GetInstanceRequest

var GetProjectCmd = &cobra.Command{
	Use:   "get-project",
	Short: "GetProject returns a specified project.",
	Long:  "GetProject returns a specified project.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if GetProjectFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if GetProjectFromFile != "" {
			in, err = os.Open(GetProjectFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &GetProjectInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Admin", "GetProject", &GetProjectInput)
		}
		resp, err := AdminClient.GetProject(ctx, &GetProjectInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetProjectFromFile string

var GetProjectInput rpcpb.GetProjectRequest

var GetStatusCmd = &cobra.Command{
	Use:   "get-status",
	Short: "GetStatus returns the status of the service.  (--...",
	Long:  "GetStatus returns the status of the service.  (-- api-linter: core::0131::request-message-name=disabled      aip.dev/not-precedent: Not in the...",
	PreRun: func(cmd *cobra.Command, args []string) {

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		if Verbose {
			printVerboseInput("Admin", "GetStatus", &GetStatusInput)
		}
		resp, err := AdminClient.GetStatus(ctx, &GetStatusInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetStatusInput emptypb.Empty

var GetStorageCmd = &cobra.Command{
	Use:   "get-storage",
	Short: "GetStorage returns information about the storage...",
	Long:  "GetStorage returns information about the storage used by the service.  (-- api-linter: core::0131::request-message-name=disabled     ...",
	PreRun: func(cmd *cobra.Command, args []string) {

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		if Verbose {
			printVerboseInput("Admin", "GetStorage", &GetStorageInput)
		}
		resp, err := AdminClient.GetStorage(ctx, &GetStorageInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var GetStorageInput emptypb.Empty

var ListApiDeploymentRevisionsCmd = &cobra.Command{
	Use:   "list-api-deployment-revisions",
	Short: "ListApiDeploymentRevisions lists all revisions of...",
	Long:  "ListApiDeploymentRevisions lists all revisions of a deployment.  Revisions are returned in descending order of revision creation time.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListApiDeploymentRevisionsFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListApiDeploymentRevisionsFromFile != "" {
			in, err = os.Open(ListApiDeploymentRevisionsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListApiDeploymentRevisionsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "ListApiDeploymentRevisions", &ListApiDeploymentRevisionsInput)
		}
		iter := RegistryClient.ListApiDeploymentRevisions(ctx, &ListApiDeploymentRevisionsInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListApiDeploymentRevisionsFromFile string

var ListApiDeploymentRevisionsInput rpcpb.ListApiDeploymentRevisionsRequest

var ListApiDeploymentsCmd = &cobra.Command{
	Use:   "list-api-deployments",
	Short: "ListApiDeployments returns matching deployments.",
	Long:  "ListApiDeployments returns matching deployments.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListApiDeploymentsFromFile == "" {

			cmd.MarkFlagRequired("parent")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListApiDeploymentsFromFile != "" {
			in, err = os.Open(ListApiDeploymentsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListApiDeploymentsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "ListApiDeployments", &ListApiDeploymentsInput)
		}
		iter := RegistryClient.ListApiDeployments(ctx, &ListApiDeploymentsInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListApiDeploymentsFromFile string

var ListApiDeploymentsInput rpcpb.ListApiDeploymentsRequest

var ListApiSpecRevisionsCmd = &cobra.Command{
	Use:   "list-api-spec-revisions",
	Short: "ListApiSpecRevisions lists all revisions of a...",
	Long:  "ListApiSpecRevisions lists all revisions of a spec.  Revisions are returned in descending order of revision creation time.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListApiSpecRevisionsFromFile == "" {

			cmd.MarkFlagRequired("name")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListApiSpecRevisionsFromFile != "" {
			in, err = os.Open(ListApiSpecRevisionsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListApiSpecRevisionsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "ListApiSpecRevisions", &ListApiSpecRevisionsInput)
		}
		iter := RegistryClient.ListApiSpecRevisions(ctx, &ListApiSpecRevisionsInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListApiSpecRevisionsFromFile string

var ListApiSpecRevisionsInput rpcpb.ListApiSpecRevisionsRequest

var ListApiSpecsCmd = &cobra.Command{
	Use:   "list-api-specs",
	Short: "ListApiSpecs returns matching specs.",
	Long:  "ListApiSpecs returns matching specs.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListApiSpecsFromFile == "" {

			cmd.MarkFlagRequired("parent")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListApiSpecsFromFile != "" {
			in, err = os.Open(ListApiSpecsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListApiSpecsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "ListApiSpecs", &ListApiSpecsInput)
		}
		iter := RegistryClient.ListApiSpecs(ctx, &ListApiSpecsInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListApiSpecsFromFile string

var ListApiSpecsInput rpcpb.ListApiSpecsRequest

var ListApiVersionsCmd = &cobra.Command{
	Use:   "list-api-versions",
	Short: "ListApiVersions returns matching versions.",
	Long:  "ListApiVersions returns matching versions.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListApiVersionsFromFile == "" {

			cmd.MarkFlagRequired("parent")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListApiVersionsFromFile != "" {
			in, err = os.Open(ListApiVersionsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListApiVersionsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "ListApiVersions", &ListApiVersionsInput)
		}
		iter := RegistryClient.ListApiVersions(ctx, &ListApiVersionsInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListApiVersionsFromFile string

var ListApiVersionsInput rpcpb.ListApiVersionsRequest

var ListApisCmd = &cobra.Command{
	Use:   "list-apis",
	Short: "ListApis returns matching APIs.",
	Long:  "ListApis returns matching APIs.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListApisFromFile == "" {

			cmd.MarkFlagRequired("parent")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListApisFromFile != "" {
			in, err = os.Open(ListApisFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListApisInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "ListApis", &ListApisInput)
		}
		iter := RegistryClient.ListApis(ctx, &ListApisInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListApisFromFile string

var ListApisInput rpcpb.ListApisRequest

var ListArtifactsCmd = &cobra.Command{
	Use:   "list-artifacts",
	Short: "ListArtifacts returns matching artifacts.",
	Long:  "ListArtifacts returns matching artifacts.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListArtifactsFromFile == "" {

			cmd.MarkFlagRequired("parent")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListArtifactsFromFile != "" {
			in, err = os.Open(ListArtifactsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListArtifactsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "ListArtifacts", &ListArtifactsInput)
		}
		iter := RegistryClient.ListArtifacts(ctx, &ListArtifactsInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListArtifactsFromFile string

var ListArtifactsInput rpcpb.ListArtifactsRequest

var ListProjectsCmd = &cobra.Command{
	Use:   "list-projects",
	Short: "ListProjects returns matching projects.  (--...",
	Long:  "ListProjects returns matching projects.  (-- api-linter: standard-methods=disabled --)  (-- api-linter: core::0132::method-signature=disabled     ...",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ListProjectsFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ListProjectsFromFile != "" {
			in, err = os.Open(ListProjectsFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ListProjectsInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Admin", "ListProjects", &ListProjectsInput)
		}
		iter := AdminClient.ListProjects(ctx, &ListProjectsInput)

		_, err = iter.Next()
		if err != nil && err != iterator.Done {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(iter.Response)

		return err
	},
}

var ListProjectsFromFile string

var ListProjectsInput rpcpb.ListProjectsRequest

var MigrateDatabaseCmd = &cobra.Command{
	Use:   "migrate-database",
	Short: "MigrateDatabase attempts to migrate the database...",
	Long:  "MigrateDatabase attempts to migrate the database to the current schema.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if MigrateDatabaseFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if MigrateDatabaseFromFile != "" {
			in, err = os.Open(MigrateDatabaseFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &MigrateDatabaseInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Admin", "MigrateDatabase", &MigrateDatabaseInput)
		}
		resp, err := AdminClient.MigrateDatabase(ctx, &MigrateDatabaseInput)
		if err != nil {
			return err
		}

		if !MigrateDatabaseFollow {
			var s interface{}
			s = resp.Name()

			if OutputJSON {
				d := make(map[string]string)
				d["operation"] = resp.Name()
				s = d
			}

			printMessage(s)
			return err
		}

		result, err := resp.Wait(ctx)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(result)

		return err
	},
}

var MigrateDatabaseFollow bool

var MigrateDatabaseFromFile string

var MigrateDatabaseInput rpcpb.MigrateDatabaseRequest

var MigrateDatabasePollCmd = &cobra.Command{
	Use:   "poll-migrate-database",
	Short: "Poll the status of a MigrateDatabaseOperation by name",
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		op := AdminClient.MigrateDatabaseOperation(MigrateDatabasePollOperation)

		if MigrateDatabaseFollow {
			resp, err := op.Wait(ctx)
			if err != nil {
				return err
			}

			if Verbose {
				fmt.Print("Output: ")
			}
			printMessage(resp)
			return err
		}

		resp, err := op.Poll(ctx)
		if err != nil {
			return err
		} else if resp != nil {
			if Verbose {
				fmt.Print("Output: ")
			}

			printMessage(resp)
			return
		}

		if op.Done() {
			fmt.Println(fmt.Sprintf("Operation %s is done", op.Name()))
		} else {
			fmt.Println(fmt.Sprintf("Operation %s not done", op.Name()))
		}

		return err
	},
}

var MigrateDatabasePollOperation string

var ProvisioningClient *gapic.ProvisioningClient

var ProvisioningServiceCmd = &cobra.Command{
	Use:       "provisioning",
	Short:     "The service that is used for managing the data...",
	Long:      "The service that is used for managing the data plane provisioning of the  Registry.",
	ValidArgs: ProvisioningSubCommands,
	PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) {
		ProvisioningClient, err = connection.NewProvisioningClient(ctx)
		return
	},
}

var ProvisioningSubCommands []string = []string{
	"create-instance",
	"poll-create-instance", "delete-instance",
	"poll-delete-instance", "get-instance",
}

var RegistryClient *gapic.RegistryClient

var RegistryServiceCmd = &cobra.Command{
	Use:       "registry",
	Short:     "The Registry service allows teams to manage...",
	Long:      "The Registry service allows teams to manage descriptions of APIs.",
	ValidArgs: RegistrySubCommands,
	PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) {
		RegistryClient, err = connection.NewRegistryClient(ctx)
		return
	},
}

var RegistrySubCommands []string = []string{
	"list-apis",
	"get-api",
	"create-api",
	"update-api",
	"delete-api",
	"list-api-versions",
	"get-api-version",
	"create-api-version",
	"update-api-version",
	"delete-api-version",
	"list-api-specs",
	"get-api-spec",
	"get-api-spec-contents",
	"create-api-spec",
	"update-api-spec",
	"delete-api-spec",
	"tag-api-spec-revision",
	"list-api-spec-revisions",
	"rollback-api-spec",
	"delete-api-spec-revision",
	"list-api-deployments",
	"get-api-deployment",
	"create-api-deployment",
	"update-api-deployment",
	"delete-api-deployment",
	"tag-api-deployment-revision",
	"list-api-deployment-revisions",
	"rollback-api-deployment",
	"delete-api-deployment-revision",
	"list-artifacts",
	"get-artifact",
	"get-artifact-contents",
	"create-artifact",
	"replace-artifact",
	"delete-artifact",
}

var ReplaceArtifactCmd = &cobra.Command{
	Use:   "replace-artifact",
	Short: "ReplaceArtifact can be used to replace a...",
	Long:  "ReplaceArtifact can be used to replace a specified artifact.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if ReplaceArtifactFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if ReplaceArtifactFromFile != "" {
			in, err = os.Open(ReplaceArtifactFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &ReplaceArtifactInput)
			if err != nil {
				return err
			}

		}

		if len(ReplaceArtifactInputArtifactLabels) > 0 {
			ReplaceArtifactInput.Artifact.Labels = make(map[string]string)
		}
		for _, item := range ReplaceArtifactInputArtifactLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			ReplaceArtifactInput.Artifact.Labels[split[0]] = split[1]
		}

		if len(ReplaceArtifactInputArtifactAnnotations) > 0 {
			ReplaceArtifactInput.Artifact.Annotations = make(map[string]string)
		}
		for _, item := range ReplaceArtifactInputArtifactAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			ReplaceArtifactInput.Artifact.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "ReplaceArtifact", &ReplaceArtifactInput)
		}
		resp, err := RegistryClient.ReplaceArtifact(ctx, &ReplaceArtifactInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var ReplaceArtifactFromFile string

var ReplaceArtifactInput rpcpb.ReplaceArtifactRequest

var ReplaceArtifactInputArtifactAnnotations []string

var ReplaceArtifactInputArtifactLabels []string

var RollbackApiDeploymentCmd = &cobra.Command{
	Use:   "rollback-api-deployment",
	Short: "RollbackApiDeployment sets the current revision...",
	Long:  "RollbackApiDeployment sets the current revision to a specified prior  revision. Note that this creates a new revision with a new revision ID.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if RollbackApiDeploymentFromFile == "" {

			cmd.MarkFlagRequired("name")

			cmd.MarkFlagRequired("revision_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if RollbackApiDeploymentFromFile != "" {
			in, err = os.Open(RollbackApiDeploymentFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &RollbackApiDeploymentInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "RollbackApiDeployment", &RollbackApiDeploymentInput)
		}
		resp, err := RegistryClient.RollbackApiDeployment(ctx, &RollbackApiDeploymentInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var RollbackApiDeploymentFromFile string

var RollbackApiDeploymentInput rpcpb.RollbackApiDeploymentRequest

var RollbackApiSpecCmd = &cobra.Command{
	Use:   "rollback-api-spec",
	Short: "RollbackApiSpec sets the current revision to a...",
	Long:  "RollbackApiSpec sets the current revision to a specified prior revision.  Note that this creates a new revision with a new revision ID.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if RollbackApiSpecFromFile == "" {

			cmd.MarkFlagRequired("name")

			cmd.MarkFlagRequired("revision_id")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if RollbackApiSpecFromFile != "" {
			in, err = os.Open(RollbackApiSpecFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &RollbackApiSpecInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "RollbackApiSpec", &RollbackApiSpecInput)
		}
		resp, err := RegistryClient.RollbackApiSpec(ctx, &RollbackApiSpecInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var RollbackApiSpecFromFile string

var RollbackApiSpecInput rpcpb.RollbackApiSpecRequest

var TagApiDeploymentRevisionCmd = &cobra.Command{
	Use:   "tag-api-deployment-revision",
	Short: "TagApiDeploymentRevision adds a tag to a...",
	Long:  "TagApiDeploymentRevision adds a tag to a specified revision of a  deployment.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if TagApiDeploymentRevisionFromFile == "" {

			cmd.MarkFlagRequired("name")

			cmd.MarkFlagRequired("tag")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if TagApiDeploymentRevisionFromFile != "" {
			in, err = os.Open(TagApiDeploymentRevisionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &TagApiDeploymentRevisionInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "TagApiDeploymentRevision", &TagApiDeploymentRevisionInput)
		}
		resp, err := RegistryClient.TagApiDeploymentRevision(ctx, &TagApiDeploymentRevisionInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var TagApiDeploymentRevisionFromFile string

var TagApiDeploymentRevisionInput rpcpb.TagApiDeploymentRevisionRequest

var TagApiSpecRevisionCmd = &cobra.Command{
	Use:   "tag-api-spec-revision",
	Short: "TagApiSpecRevision adds a tag to a specified...",
	Long:  "TagApiSpecRevision adds a tag to a specified revision of a spec.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if TagApiSpecRevisionFromFile == "" {

			cmd.MarkFlagRequired("name")

			cmd.MarkFlagRequired("tag")

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if TagApiSpecRevisionFromFile != "" {
			in, err = os.Open(TagApiSpecRevisionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &TagApiSpecRevisionInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Registry", "TagApiSpecRevision", &TagApiSpecRevisionInput)
		}
		resp, err := RegistryClient.TagApiSpecRevision(ctx, &TagApiSpecRevisionInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var TagApiSpecRevisionFromFile string

var TagApiSpecRevisionInput rpcpb.TagApiSpecRevisionRequest

var UpdateApiCmd = &cobra.Command{
	Use:   "update-api",
	Short: "UpdateApi can be used to modify a specified API.",
	Long:  "UpdateApi can be used to modify a specified API.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if UpdateApiFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if UpdateApiFromFile != "" {
			in, err = os.Open(UpdateApiFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &UpdateApiInput)
			if err != nil {
				return err
			}

		}

		if len(UpdateApiInputApiLabels) > 0 {
			UpdateApiInput.Api.Labels = make(map[string]string)
		}
		for _, item := range UpdateApiInputApiLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiInput.Api.Labels[split[0]] = split[1]
		}

		if len(UpdateApiInputApiAnnotations) > 0 {
			UpdateApiInput.Api.Annotations = make(map[string]string)
		}
		for _, item := range UpdateApiInputApiAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiInput.Api.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "UpdateApi", &UpdateApiInput)
		}
		resp, err := RegistryClient.UpdateApi(ctx, &UpdateApiInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var UpdateApiDeploymentCmd = &cobra.Command{
	Use:   "update-api-deployment",
	Short: "UpdateApiDeployment can be used to modify a...",
	Long:  "UpdateApiDeployment can be used to modify a specified deployment.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if UpdateApiDeploymentFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if UpdateApiDeploymentFromFile != "" {
			in, err = os.Open(UpdateApiDeploymentFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &UpdateApiDeploymentInput)
			if err != nil {
				return err
			}

		}

		if len(UpdateApiDeploymentInputApiDeploymentLabels) > 0 {
			UpdateApiDeploymentInput.ApiDeployment.Labels = make(map[string]string)
		}
		for _, item := range UpdateApiDeploymentInputApiDeploymentLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiDeploymentInput.ApiDeployment.Labels[split[0]] = split[1]
		}

		if len(UpdateApiDeploymentInputApiDeploymentAnnotations) > 0 {
			UpdateApiDeploymentInput.ApiDeployment.Annotations = make(map[string]string)
		}
		for _, item := range UpdateApiDeploymentInputApiDeploymentAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiDeploymentInput.ApiDeployment.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "UpdateApiDeployment", &UpdateApiDeploymentInput)
		}
		resp, err := RegistryClient.UpdateApiDeployment(ctx, &UpdateApiDeploymentInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var UpdateApiDeploymentFromFile string

var UpdateApiDeploymentInput rpcpb.UpdateApiDeploymentRequest

var UpdateApiDeploymentInputApiDeploymentAnnotations []string

var UpdateApiDeploymentInputApiDeploymentLabels []string

var UpdateApiFromFile string

var UpdateApiInput rpcpb.UpdateApiRequest

var UpdateApiInputApiAnnotations []string

var UpdateApiInputApiLabels []string

var UpdateApiSpecCmd = &cobra.Command{
	Use:   "update-api-spec",
	Short: "UpdateApiSpec can be used to modify a specified...",
	Long:  "UpdateApiSpec can be used to modify a specified spec.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if UpdateApiSpecFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if UpdateApiSpecFromFile != "" {
			in, err = os.Open(UpdateApiSpecFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &UpdateApiSpecInput)
			if err != nil {
				return err
			}

		}

		if len(UpdateApiSpecInputApiSpecLabels) > 0 {
			UpdateApiSpecInput.ApiSpec.Labels = make(map[string]string)
		}
		for _, item := range UpdateApiSpecInputApiSpecLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiSpecInput.ApiSpec.Labels[split[0]] = split[1]
		}

		if len(UpdateApiSpecInputApiSpecAnnotations) > 0 {
			UpdateApiSpecInput.ApiSpec.Annotations = make(map[string]string)
		}
		for _, item := range UpdateApiSpecInputApiSpecAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiSpecInput.ApiSpec.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "UpdateApiSpec", &UpdateApiSpecInput)
		}
		resp, err := RegistryClient.UpdateApiSpec(ctx, &UpdateApiSpecInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var UpdateApiSpecFromFile string

var UpdateApiSpecInput rpcpb.UpdateApiSpecRequest

var UpdateApiSpecInputApiSpecAnnotations []string

var UpdateApiSpecInputApiSpecLabels []string

var UpdateApiVersionCmd = &cobra.Command{
	Use:   "update-api-version",
	Short: "UpdateApiVersion can be used to modify a...",
	Long:  "UpdateApiVersion can be used to modify a specified version.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if UpdateApiVersionFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if UpdateApiVersionFromFile != "" {
			in, err = os.Open(UpdateApiVersionFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &UpdateApiVersionInput)
			if err != nil {
				return err
			}

		}

		if len(UpdateApiVersionInputApiVersionLabels) > 0 {
			UpdateApiVersionInput.ApiVersion.Labels = make(map[string]string)
		}
		for _, item := range UpdateApiVersionInputApiVersionLabels {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiVersionInput.ApiVersion.Labels[split[0]] = split[1]
		}

		if len(UpdateApiVersionInputApiVersionAnnotations) > 0 {
			UpdateApiVersionInput.ApiVersion.Annotations = make(map[string]string)
		}
		for _, item := range UpdateApiVersionInputApiVersionAnnotations {
			split := strings.Split(item, "=")
			if len(split) < 2 {
				err = fmt.Errorf("Invalid map item: %q", item)
				return
			}

			UpdateApiVersionInput.ApiVersion.Annotations[split[0]] = split[1]
		}

		if Verbose {
			printVerboseInput("Registry", "UpdateApiVersion", &UpdateApiVersionInput)
		}
		resp, err := RegistryClient.UpdateApiVersion(ctx, &UpdateApiVersionInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var UpdateApiVersionFromFile string

var UpdateApiVersionInput rpcpb.UpdateApiVersionRequest

var UpdateApiVersionInputApiVersionAnnotations []string

var UpdateApiVersionInputApiVersionLabels []string

var UpdateProjectCmd = &cobra.Command{
	Use:   "update-project",
	Short: "UpdateProject can be used to modify a specified...",
	Long:  "UpdateProject can be used to modify a specified project.",
	PreRun: func(cmd *cobra.Command, args []string) {

		if UpdateProjectFromFile == "" {

		}

	},
	RunE: func(cmd *cobra.Command, args []string) (err error) {

		in := os.Stdin
		if UpdateProjectFromFile != "" {
			in, err = os.Open(UpdateProjectFromFile)
			if err != nil {
				return err
			}
			defer in.Close()

			err = jsonpb.Unmarshal(in, &UpdateProjectInput)
			if err != nil {
				return err
			}

		}

		if Verbose {
			printVerboseInput("Admin", "UpdateProject", &UpdateProjectInput)
		}
		resp, err := AdminClient.UpdateProject(ctx, &UpdateProjectInput)
		if err != nil {
			return err
		}

		if Verbose {
			fmt.Print("Output: ")
		}
		printMessage(resp)

		return err
	},
}

var UpdateProjectFromFile string

var UpdateProjectInput rpcpb.UpdateProjectRequest

var Verbose, OutputJSON bool