mist-api-v2.go

// Code generated by openapi-cli-generator. DO NOT EDIT.
// See https://gitlab.ops.mist.io/mistio/openapi-cli-generator

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/jmespath/go-jmespath"
	"github.com/pkg/errors"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
	"gitlab.ops.mist.io/mistio/openapi-cli-generator/cli"
	terminal "golang.org/x/term"
	"gopkg.in/h2non/gentleman.v2"
)

var mistApiV2Subcommand bool

func mistApiV2Servers() []map[string]string {
	return []map[string]string{

		map[string]string{
			"description": "Mist Hosted Service",
			"url":         "https://mist.io/",
		},
	}
}

func setContext() error {
	context := viper.GetString("context")
	contextDefault := cli.Creds.GetString("default.context")
	if context == "" {
		if contextDefault == "" {
			contexts := cli.Creds.GetStringMap("contexts")
			if len(contexts) == 0 {
				return errors.Errorf("No contexts configured. Use `%s config add-context` to add one.", cli.Root.CommandPath())
			}
			for k, _ := range contexts {
				context = k
				break
			}
		} else {
			context = contextDefault
		}
	}
	if cli.ExistsContext(context) {
		viper.Set("context", context)
		if contextDefault == "" {
			cli.UpdateDefaultContext(context)
		}
		return nil
	}
	return errors.Errorf("Context %s not configured. Use `%s config add-context` to add it.", context, cli.Root.CommandPath())
}

func getServer() (string, error) {
	server := viper.GetString("server")
	if server == "" {
		var ok bool
		server, ok = cli.GetContext()["server"]
		if !ok {
			server = cli.Creds.GetString("default.server")
			if server == "" {
				if len(mistApiV2Servers()) > 0 {
					server = mistApiV2Servers()[0]["url"]
					cli.UpdateDefaultServer(server)
				} else {
					return "", errors.Errorf("No default server url found.")
				}
			}
		}
	}
	return strings.TrimSuffix(server, "/"), nil
}

func getToken() (string, error) {
	err := setContext()
	if err != nil {
		return "", err
	}
	context := cli.Creds.GetString("default.context")
	return cli.Creds.GetString("contexts." + context + ".api_key"), nil
}

// MistApiV2ListClouds List clouds
func MistApiV2ListClouds(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-clouds"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clouds"

	req := cli.Client.Get().URL(url)

	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "provider", "tags"}, []string{"id", "name", "provider", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2AddCloud Add cloud
func MistApiV2AddCloud(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "add-cloud"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clouds"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2RemoveCloud Remove cloud
func MistApiV2RemoveCloud(paramCloud string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "remove-cloud"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clouds/{cloud}"
	url = strings.Replace(url, "{cloud}", paramCloud, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetCloud Get cloud
func MistApiV2GetCloud(paramCloud string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-cloud"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clouds/{cloud}"
	url = strings.Replace(url, "{cloud}", paramCloud, 1)

	req := cli.Client.Get().URL(url)

	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "provider", "tags"}, []string{"id", "name", "provider", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditCloud Edit cloud
func MistApiV2EditCloud(paramCloud string, params *viper.Viper, body string) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-cloud"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clouds/{cloud}"
	url = strings.Replace(url, "{cloud}", paramCloud, 1)

	req := cli.Client.Put().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListClusters List clusters
func MistApiV2ListClusters(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-clusters"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clusters"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}
	paramCredentials := params.GetBool("credentials")
	if paramCredentials != false {
		req = req.AddQuery("credentials", fmt.Sprintf("%v", paramCredentials))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "total_nodes", "tags"}, []string{"id", "name", "cloud", "total_nodes", "total_cpus", "total_ram", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateCluster Create cluster
func MistApiV2CreateCluster(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-cluster"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clusters"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DestroyCluster Destroy cluster
func MistApiV2DestroyCluster(paramCluster string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "destroy-cluster"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clusters/{cluster}"
	url = strings.Replace(url, "{cluster}", paramCluster, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetCluster Get cluster
func MistApiV2GetCluster(paramCluster string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-cluster"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clusters/{cluster}"
	url = strings.Replace(url, "{cluster}", paramCluster, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramCredentials := params.GetBool("credentials")
	if paramCredentials != false {
		req = req.AddQuery("credentials", fmt.Sprintf("%v", paramCredentials))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "total_nodes", "tags"}, []string{"id", "name", "cloud", "total_nodes", "total_cpus", "total_ram", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{"credentials": "bool"}}, nil
}

// MistApiV2ScaleNodepool Scale cluster nodepool
func MistApiV2ScaleNodepool(paramCluster string, paramNodepool string, params *viper.Viper, body string) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "scale-nodepool"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/clusters/{cluster}/nodepools/{nodepool}"
	url = strings.Replace(url, "{cluster}", paramCluster, 1)
	url = strings.Replace(url, "{nodepool}", paramNodepool, 1)

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetDatapoints Get datapoints
func MistApiV2GetDatapoints(paramQuery string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-datapoints"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/datapoints"

	req := cli.Client.Get().URL(url)

	req = req.AddQuery("query", paramQuery)

	paramTags := params.GetString("tags")
	if paramTags != "" {
		req = req.AddQuery("tags", fmt.Sprintf("%v", paramTags))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramEnd := params.GetString("end")
	if paramEnd != "" {
		req = req.AddQuery("end", fmt.Sprintf("%v", paramEnd))
	}
	paramStep := params.GetString("step")
	if paramStep != "" {
		req = req.AddQuery("step", fmt.Sprintf("%v", paramStep))
	}
	paramTime := params.GetString("time")
	if paramTime != "" {
		req = req.AddQuery("time", fmt.Sprintf("%v", paramTime))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListImages List images
func MistApiV2ListImages(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-images"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/images"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"starred", "name", "cloud", "os_type", "tags"}, []string{"starred", "id", "external_id", "name", "cloud", "os_type", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetImage Get image
func MistApiV2GetImage(paramImage string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-image"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/images/{image}"
	url = strings.Replace(url, "{image}", paramImage, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"starred", "name", "cloud", "os_type", "tags"}, []string{"starred", "id", "external_id", "name", "cloud", "os_type", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetJob Get job
func MistApiV2GetJob(paramJobId string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-job"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/jobs/{job_id}"
	url = strings.Replace(url, "{job_id}", paramJobId, 1)

	req := cli.Client.Get().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListKeys List keys
func MistApiV2ListKeys(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-keys"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/keys"

	req := cli.Client.Get().URL(url)

	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}
	paramPrivate := params.GetBool("private")
	if paramPrivate != false {
		req = req.AddQuery("private", fmt.Sprintf("%v", paramPrivate))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "default", "tags"}, []string{"id", "name", "default", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2AddKey Add key
func MistApiV2AddKey(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "add-key"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/keys"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteKey Delete key
func MistApiV2DeleteKey(paramKey string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-key"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/keys/{key}"
	url = strings.Replace(url, "{key}", paramKey, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetKey Get key
func MistApiV2GetKey(paramKey string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-key"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/keys/{key}"
	url = strings.Replace(url, "{key}", paramKey, 1)

	req := cli.Client.Get().URL(url)

	paramPrivate := params.GetBool("private")
	if paramPrivate != false {
		req = req.AddQuery("private", fmt.Sprintf("%v", paramPrivate))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "default", "tags"}, []string{"id", "name", "default", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{"private": "bool"}}, nil
}

// MistApiV2EditKey Edit key
func MistApiV2EditKey(paramKey string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-key"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/keys/{key}"
	url = strings.Replace(url, "{key}", paramKey, 1)

	req := cli.Client.Put().URL(url)

	paramName := params.GetString("name")
	if paramName != "" {
		req = req.AddQuery("name", fmt.Sprintf("%v", paramName))
	}
	paramDefault := params.GetBool("default")
	if paramDefault != false {
		req = req.AddQuery("default", fmt.Sprintf("%v", paramDefault))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListLocations List locations
func MistApiV2ListLocations(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-locations"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/locations"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud"}, []string{"id", "name", "cloud", "external_id", "machines"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetLocation Get location
func MistApiV2GetLocation(paramLocation string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-location"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/locations/{location}"
	url = strings.Replace(url, "{location}", paramLocation, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud"}, []string{"id", "name", "cloud", "locations", "external_id", "machines"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListMachines List machines
func MistApiV2ListMachines(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-machines"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "state", "tags"}, []string{"id", "name", "state", "cloud", "external_id", "public_ips", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateMachine Create machine
func MistApiV2CreateMachine(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetMachine Get machine
func MistApiV2GetMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "state", "tags"}, []string{"id", "name", "state", "cloud", "external_id", "public_ips", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditMachine Edit machine
func MistApiV2EditMachine(paramMachine string, params *viper.Viper, body string) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Put().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2AssociateKey Associate a key with a machine
func MistApiV2AssociateKey(paramMachine string, params *viper.Viper, body string) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "associate-key"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/associate-key"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Put().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CloneMachine Clone machine
func MistApiV2CloneMachine(paramMachine string, paramName string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "clone-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/clone"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	req = req.AddQuery("name", paramName)

	paramRunAsync := params.GetBool("run-async")
	if paramRunAsync != false {
		req = req.AddQuery("run_async", fmt.Sprintf("%v", paramRunAsync))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DestroyMachine Destroy machine
func MistApiV2DestroyMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "destroy-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/destroy"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DisassociateKey Disassociate a key from a machine
func MistApiV2DisassociateKey(paramMachine string, params *viper.Viper, body string) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "disassociate-key"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/disassociate-key"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Delete().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2RebootMachine Reboot machine
func MistApiV2RebootMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "reboot-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/reboot"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2RenameMachine Rename machine
func MistApiV2RenameMachine(paramMachine string, paramName string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "rename-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/rename"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	req = req.AddQuery("name", paramName)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ResizeMachine Resize machine
func MistApiV2ResizeMachine(paramMachine string, paramSize string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "resize-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/resize"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	req = req.AddQuery("size", paramSize)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ResumeMachine Resume machine
func MistApiV2ResumeMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "resume-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/resume"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2StartMachine Start machine
func MistApiV2StartMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "start-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/start"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2StopMachine Stop machine
func MistApiV2StopMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "stop-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/stop"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2SuspendMachine Suspend machine
func MistApiV2SuspendMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "suspend-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/suspend"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2UndefineMachine Undefine machine
func MistApiV2UndefineMachine(paramMachine string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "undefine-machine"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/actions/undefine"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	paramDeleteDomainImage := params.GetBool("delete-domain-image")
	if paramDeleteDomainImage != false {
		req = req.AddQuery("delete_domain_image", fmt.Sprintf("%v", paramDeleteDomainImage))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListSnapshots List machine snapshots
func MistApiV2ListSnapshots(paramMachine string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-snapshots"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/snapshots"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Get().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateSnapshot Create snapshot
func MistApiV2CreateSnapshot(paramMachine string, paramName string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-snapshot"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/snapshots"
	url = strings.Replace(url, "{machine}", paramMachine, 1)

	req := cli.Client.Post().URL(url)

	req = req.AddQuery("name", paramName)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2RemoveSnapshot Remove snapshot
func MistApiV2RemoveSnapshot(paramMachine string, paramSnapshot string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "remove-snapshot"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/snapshots/{snapshot}"
	url = strings.Replace(url, "{machine}", paramMachine, 1)
	url = strings.Replace(url, "{snapshot}", paramSnapshot, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2RevertToSnapshot Revert to snapshot
func MistApiV2RevertToSnapshot(paramMachine string, paramSnapshot string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "revert-to-snapshot"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/machines/{machine}/snapshots/{snapshot}"
	url = strings.Replace(url, "{machine}", paramMachine, 1)
	url = strings.Replace(url, "{snapshot}", paramSnapshot, 1)

	req := cli.Client.Post().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListNetworks List networks
func MistApiV2ListNetworks(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-networks"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/networks"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "machines", "tags"}, []string{"id", "name", "cloud", "external_id", "machines", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateNetwork Create network
func MistApiV2CreateNetwork(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-network"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/networks"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteNetwork Delete network
func MistApiV2DeleteNetwork(paramNetwork string, paramCloud string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-network"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/networks/{network}"
	url = strings.Replace(url, "{network}", paramNetwork, 1)

	req := cli.Client.Delete().URL(url)

	req = req.AddQuery("cloud", paramCloud)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetNetwork Get network
func MistApiV2GetNetwork(paramNetwork string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-network"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/networks/{network}"
	url = strings.Replace(url, "{network}", paramNetwork, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "machines", "tags"}, []string{"id", "name", "cloud", "location", "external_id", "subnets", "machines", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditNetwork Edit network
func MistApiV2EditNetwork(paramNetwork string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-network"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/networks/{network}"
	url = strings.Replace(url, "{network}", paramNetwork, 1)

	req := cli.Client.Put().URL(url)

	paramName := params.GetString("name")
	if paramName != "" {
		req = req.AddQuery("name", fmt.Sprintf("%v", paramName))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListRules List rules
func MistApiV2ListRules(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-rules"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/rules"

	req := cli.Client.Get().URL(url)

	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "queries", "actions", "tags"}, []string{"id", "name", "resource_type", "selectors", "queries", "actions", "window", "frequency", "tags"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2AddRule Add rule
func MistApiV2AddRule(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "add-rule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/rules"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteRule Delete rule
func MistApiV2DeleteRule(paramRule string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-rule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/rules/{rule}"
	url = strings.Replace(url, "{rule}", paramRule, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetRule Get rule
func MistApiV2GetRule(paramRule string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-rule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/rules/{rule}"
	url = strings.Replace(url, "{rule}", paramRule, 1)

	req := cli.Client.Get().URL(url)

	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "queries", "actions", "tags"}, []string{"id", "name", "resource_type", "selectors", "queries", "actions", "window", "frequency", "tags"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2RenameRule Rename rule
func MistApiV2RenameRule(paramRule string, paramName string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "rename-rule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/rules/{rule}"
	url = strings.Replace(url, "{rule}", paramRule, 1)

	req := cli.Client.Patch().URL(url)

	req = req.AddQuery("name", paramName)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditRule Update rule
func MistApiV2EditRule(paramRule string, params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-rule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/rules/{rule}"
	url = strings.Replace(url, "{rule}", paramRule, 1)

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ToggleRule Toggle rule
func MistApiV2ToggleRule(paramRule string, paramAction string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "toggle-rule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/rules/{rule}"
	url = strings.Replace(url, "{rule}", paramRule, 1)

	req := cli.Client.Put().URL(url)

	req = req.AddQuery("action", paramAction)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListSchedules List schedules
func MistApiV2ListSchedules(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-schedules"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/schedules"

	req := cli.Client.Get().URL(url)

	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "tags"}, []string{"id", "name", "description", "tags", "enabled", "action", "script_id", "params", "selectors", "schedule_type", "schedule_entry", "start_after", "run_immediately", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2AddSchedule Add schedule
func MistApiV2AddSchedule(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "add-schedule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/schedules"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteSchedule Delete schedule
func MistApiV2DeleteSchedule(paramSchedule string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-schedule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/schedules/{schedule}"
	url = strings.Replace(url, "{schedule}", paramSchedule, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetSchedule Get schedule
func MistApiV2GetSchedule(paramSchedule string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-schedule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/schedules/{schedule}"
	url = strings.Replace(url, "{schedule}", paramSchedule, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "tags"}, []string{"id", "name", "description", "tags", "enabled", "action", "script_id", "params", "selectors", "schedule_type", "schedule_entry", "start_after", "run_immediately", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditSchedule Edit schedule
func MistApiV2EditSchedule(paramSchedule string, params *viper.Viper, body string) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-schedule"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/schedules/{schedule}"
	url = strings.Replace(url, "{schedule}", paramSchedule, 1)

	req := cli.Client.Patch().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListScripts List scripts
func MistApiV2ListScripts(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-scripts"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts"

	req := cli.Client.Get().URL(url)

	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "tags"}, []string{"id", "name", "description", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2AddScript Add script
func MistApiV2AddScript(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "add-script"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteScript Delete script
func MistApiV2DeleteScript(paramScript string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-script"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts/{script}"
	url = strings.Replace(url, "{script}", paramScript, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetScript Get script
func MistApiV2GetScript(paramScript string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-script"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts/{script}"
	url = strings.Replace(url, "{script}", paramScript, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "tags"}, []string{"id", "name", "description", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2RunScript Run script
func MistApiV2RunScript(paramScript string, params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "run-script"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts/{script}"
	url = strings.Replace(url, "{script}", paramScript, 1)

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditScript Edit script
func MistApiV2EditScript(paramScript string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-script"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts/{script}"
	url = strings.Replace(url, "{script}", paramScript, 1)

	req := cli.Client.Put().URL(url)

	paramName := params.GetString("name")
	if paramName != "" {
		req = req.AddQuery("name", fmt.Sprintf("%v", paramName))
	}
	paramDescription := params.GetString("description")
	if paramDescription != "" {
		req = req.AddQuery("description", fmt.Sprintf("%v", paramDescription))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DownloadScript Download script
func MistApiV2DownloadScript(paramScript string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "download-script"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts/{script}/file"
	url = strings.Replace(url, "{script}", paramScript, 1)

	req := cli.Client.Get().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GenerateScriptUrl Generate script url
func MistApiV2GenerateScriptUrl(paramScript string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "generate-script-url"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/scripts/{script}/url"
	url = strings.Replace(url, "{script}", paramScript, 1)

	req := cli.Client.Get().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListSecrets List secrets
func MistApiV2ListSecrets(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-secrets"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/secrets"

	req := cli.Client.Get().URL(url)

	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramValue := params.GetBool("value")
	if paramValue != false {
		req = req.AddQuery("value", fmt.Sprintf("%v", paramValue))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"id", "name", "tags"}, []string{"id", "name", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateSecret Create secret
func MistApiV2CreateSecret(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-secret"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/secrets"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteSecret Delete secret
func MistApiV2DeleteSecret(paramSecret string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-secret"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/secrets/{secret}"
	url = strings.Replace(url, "{secret}", paramSecret, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetSecret Get secret
func MistApiV2GetSecret(paramSecret string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-secret"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/secrets/{secret}"
	url = strings.Replace(url, "{secret}", paramSecret, 1)

	req := cli.Client.Get().URL(url)

	paramValue := params.GetBool("value")
	if paramValue != false {
		req = req.AddQuery("value", fmt.Sprintf("%v", paramValue))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"id", "name", "tags"}, []string{"id", "name", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{"value": "bool"}}, nil
}

// MistApiV2EditSecret Edit secret
func MistApiV2EditSecret(paramSecret string, params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-secret"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/secrets/{secret}"
	url = strings.Replace(url, "{secret}", paramSecret, 1)

	req := cli.Client.Put().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListSizes List sizes
func MistApiV2ListSizes(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-sizes"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/sizes"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud"}, []string{"id", "name", "cloud", "external_id", "machines"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetSize Get size
func MistApiV2GetSize(paramSize string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-size"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/sizes/{size}"
	url = strings.Replace(url, "{size}", paramSize, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud"}, []string{"id", "name", "cloud", "locations", "external_id", "machines"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListTags List tags
func MistApiV2ListTags(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-tags"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/tags"

	req := cli.Client.Get().URL(url)

	paramTypes := params.GetString("types")
	if paramTypes != "" {
		req = req.AddQuery("types", fmt.Sprintf("%v", paramTypes))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"tag", "buckets", "clouds", "clusters", "images", "keys", "machines", "networks", "records", "schedules", "scripts", "secrets", "stacks", "subnets", "templates", "tunnels", "volumes", "zones", "resource_count"}, []string{"tag", "buckets", "clouds", "clusters", "images", "keys", "machines", "networks", "records", "schedules", "scripts", "secrets", "stacks", "subnets", "templates", "tunnels", "volumes", "zones", "resource_count"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListUsers List users
func MistApiV2ListUsers(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-users"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/users"

	req := cli.Client.Get().URL(url)

	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"email"}, []string{"email", "id", "last_login", "registration_date"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListVolumes List volumes
func MistApiV2ListVolumes(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-volumes"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/volumes"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "size", "cloud", "location", "attached_to", "tags"}, []string{"id", "name", "size", "cloud", "location", "external_id", "attached_to", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateVolume Create volume
func MistApiV2CreateVolume(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-volume"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/volumes"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteVolume Delete volume
func MistApiV2DeleteVolume(paramVolume string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-volume"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/volumes/{volume}"
	url = strings.Replace(url, "{volume}", paramVolume, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetVolume Get volume
func MistApiV2GetVolume(paramVolume string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-volume"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/volumes/{volume}"
	url = strings.Replace(url, "{volume}", paramVolume, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "size", "cloud", "location", "attached_to", "tags"}, []string{"id", "name", "size", "cloud", "location", "external_id", "attached_to", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditVolume Edit volume
func MistApiV2EditVolume(paramVolume string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-volume"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/volumes/{volume}"
	url = strings.Replace(url, "{volume}", paramVolume, 1)

	req := cli.Client.Put().URL(url)

	paramName := params.GetString("name")
	if paramName != "" {
		req = req.AddQuery("name", fmt.Sprintf("%v", paramName))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListZones List zones
func MistApiV2ListZones(params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-zones"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones"

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramSearch := params.GetString("search")
	if paramSearch != "" {
		req = req.AddQuery("search", fmt.Sprintf("%v", paramSearch))
	}
	paramSort := params.GetString("sort")
	if paramSort != "" {
		req = req.AddQuery("sort", fmt.Sprintf("%v", paramSort))
	}
	paramStart := params.GetString("start")
	if paramStart != "" {
		req = req.AddQuery("start", fmt.Sprintf("%v", paramStart))
	}
	paramLimit := params.GetInt64("limit")
	if paramLimit != 0 {
		req = req.AddQuery("limit", fmt.Sprintf("%v", paramLimit))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}
	paramAt := params.GetString("at")
	if paramAt != "" {
		req = req.AddQuery("at", fmt.Sprintf("%v", paramAt))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "machines", "tags"}, []string{"id", "name", "cloud", "external_id", "machines", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateZone Create zone
func MistApiV2CreateZone(params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-zone"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones"

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteZone Delete zone
func MistApiV2DeleteZone(paramZone string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-zone"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones/{zone}"
	url = strings.Replace(url, "{zone}", paramZone, 1)

	req := cli.Client.Delete().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetZone Get zone
func MistApiV2GetZone(paramZone string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-zone"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones/{zone}"
	url = strings.Replace(url, "{zone}", paramZone, 1)

	req := cli.Client.Get().URL(url)

	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud", "machines", "tags"}, []string{"id", "name", "cloud", "location", "external_id", "subnets", "machines", "tags", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2EditZone Edit zone
func MistApiV2EditZone(paramZone string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "edit-zone"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones/{zone}"
	url = strings.Replace(url, "{zone}", paramZone, 1)

	req := cli.Client.Put().URL(url)

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2ListRecords List records
func MistApiV2ListRecords(paramZone string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "list-records"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones/{zone}/records"
	url = strings.Replace(url, "{zone}", paramZone, 1)

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud"}, []string{"id", "name", "cloud", "external_id"}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2CreateRecord Create record
func MistApiV2CreateRecord(paramZone string, params *viper.Viper, body string) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "create-record"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones/{zone}/records"
	url = strings.Replace(url, "{zone}", paramZone, 1)

	req := cli.Client.Post().URL(url)

	if body != "" {
		req = req.AddHeader("Content-Type", "application/json").BodyString(body)
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2DeleteRecord Delete record
func MistApiV2DeleteRecord(paramZone string, paramRecord string, params *viper.Viper) (*gentleman.Response, interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "delete-record"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones/{zone}/records/{record}"
	url = strings.Replace(url, "{zone}", paramZone, 1)
	url = strings.Replace(url, "{record}", paramRecord, 1)

	req := cli.Client.Delete().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{}, []string{}, []string{}, []string{}, map[string]string{}}, nil
}

// MistApiV2GetRecord Get record
func MistApiV2GetRecord(paramZone string, paramRecord string, params *viper.Viper) (*gentleman.Response, map[string]interface{}, cli.CLIOutputOptions, error) {
	handlerPath := "get-record"
	if mistApiV2Subcommand {
		handlerPath = "Mist CLI " + handlerPath
	}

	err := setContext()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	server, err := getServer()
	if err != nil {
		return nil, nil, cli.CLIOutputOptions{}, err
	}

	url := server + "/api/v2/zones/{zone}/records/{record}"
	url = strings.Replace(url, "{zone}", paramZone, 1)
	url = strings.Replace(url, "{record}", paramRecord, 1)

	req := cli.Client.Get().URL(url)

	paramCloud := params.GetString("cloud")
	if paramCloud != "" {
		req = req.AddQuery("cloud", fmt.Sprintf("%v", paramCloud))
	}
	paramOnly := params.GetString("only")
	if paramOnly != "" {
		req = req.AddQuery("only", fmt.Sprintf("%v", paramOnly))
	}
	paramDeref := params.GetString("deref")
	if paramDeref != "" {
		req = req.AddQuery("deref", fmt.Sprintf("%v", paramDeref))
	}

	cli.HandleBefore(handlerPath, params, req)

	resp, err := req.Do()
	if err != nil {
		return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Request failed")
	}

	var decoded map[string]interface{}

	if resp.StatusCode < 400 {
		if err := cli.UnmarshalResponse(resp, &decoded); err != nil {
			return resp, nil, cli.CLIOutputOptions{}, errors.Wrap(err, "Unmarshalling response failed")
		}
	} else {
		return resp, nil, cli.CLIOutputOptions{}, errors.Errorf("HTTP %d: %s", resp.StatusCode, resp.String())
	}

	after := cli.HandleAfter(handlerPath, params, resp, decoded)
	if after != nil {
		decoded = after.(map[string]interface{})
	}

	return resp, decoded, cli.CLIOutputOptions{[]string{"name", "cloud"}, []string{"id", "name", "cloud", "external_id", "owned_by", "created_by"}, []string{}, []string{}, map[string]string{}}, nil
}

func MistApiV2JobFinishedWaiter(paramJobId string, params *viper.Viper) error {
	attempt := 0
	var updatesNew interface{}
	var updatesOld interface{}
	for attempt < 900 {
		attempt++

		resp, decoded, _, err := MistApiV2GetJob(paramJobId, params)
		retryCodes := []int{
			404,
		}
		if resp != nil {
			retry := false
			for _, retryCode := range retryCodes {
				if retryCode == resp.StatusCode {
					retry = true
				}
			}
			if retry {
				time.Sleep(2 * time.Second)
				continue
			}
		}
		if err != nil {
			return errors.Wrap(err, "Could not call waiter operation")
		}

		updatesOld = updatesNew
		updatesNew, err = cli.GetMatchValue(resp.Context, "response.body#data.logs[:].action", params.AllSettings(), decoded)

		if !cli.ObjectsAreEqualValues(updatesNew, updatesOld) {
			startIndex := 0
			if updatesOld != nil {
				updatesOldList := updatesOld.([]interface{})
				startIndex = len(updatesOldList)
			}
			if updatesNew != nil {
				updatesNewList := updatesNew.([]interface{})
				for _, update := range updatesNewList[startIndex:] {
					fmt.Printf(" * %s\n", update)
				}
			}
		}

		var actual interface{}
		var match bool

		actual, err = cli.GetMatchValue(resp.Context, "response.body#data.error", params.AllSettings(), decoded)
		if err != nil {
			return errors.Wrap(err, "Could not get matcher value")
		}

		match, err = cli.Match("notEqual", []byte("false"), actual)
		if err != nil {
			return errors.Wrap(err, "Watcher match failure")
		} else if match {

			width, _, err := terminal.GetSize(int(os.Stdout.Fd()))
			if err != nil {
				return errors.Wrap(err, "Watcher match failure")
			}
			marshalled, err := json.Marshal(actual)
			if err != nil {
				return errors.Wrap(err, "Watcher match failure")
			}
			errorMessage := string(marshalled)
			if len(errorMessage) > width {
				errorMessage = errorMessage[len(errorMessage)-width:]
			}
			return errors.Errorf("%s", errorMessage)

		}

		actual, err = cli.GetMatchValue(resp.Context, "response.body#data.finished_at", params.AllSettings(), decoded)
		if err != nil {
			return errors.Wrap(err, "Could not get matcher value")
		}

		match, err = cli.Match("notEqual", []byte("0"), actual)
		if err != nil {
			return errors.Wrap(err, "Watcher match failure")
		} else if match {

			break

		}

		time.Sleep(2 * time.Second)
	}

	if attempt >= 900 {
		return errors.New("Maximum attempts exceeded")
	}

	return nil
}

func mistApiV2Register(subcommand bool) {
	root := cli.Root
	root.SetUsageTemplate(customUsageTpl)

	if subcommand {
		root = &cobra.Command{
			Use:   "Mist CLI",
			Short: "Mist API",
			Long:  cli.Markdown(""),
		}
		mistApiV2Subcommand = true
	} else {
		cli.Root.Short = "Mist API"
		cli.Root.Long = cli.Markdown("")
	}

	addCmd := &cobra.Command{
		Use:   "add",
		Short: "add",
	}
	root.AddCommand(addCmd)

	associateCmd := &cobra.Command{
		Use:   "associate",
		Short: "associate",
	}
	root.AddCommand(associateCmd)

	cloneCmd := &cobra.Command{
		Use:   "clone",
		Short: "clone",
	}
	root.AddCommand(cloneCmd)

	createCmd := &cobra.Command{
		Use:   "create",
		Short: "create",
	}
	root.AddCommand(createCmd)

	deleteCmd := &cobra.Command{
		Use:   "delete",
		Short: "delete",
	}
	root.AddCommand(deleteCmd)

	destroyCmd := &cobra.Command{
		Use:   "destroy",
		Short: "destroy",
	}
	root.AddCommand(destroyCmd)

	disassociateCmd := &cobra.Command{
		Use:   "disassociate",
		Short: "disassociate",
	}
	root.AddCommand(disassociateCmd)

	downloadCmd := &cobra.Command{
		Use:   "download",
		Short: "download",
	}
	root.AddCommand(downloadCmd)

	editCmd := &cobra.Command{
		Use:   "edit",
		Short: "edit",
	}
	root.AddCommand(editCmd)

	generateCmd := &cobra.Command{
		Use:   "generate",
		Short: "generate",
	}
	root.AddCommand(generateCmd)

	getCmd := &cobra.Command{
		Use:   "get",
		Short: "get",
	}
	root.AddCommand(getCmd)

	rebootCmd := &cobra.Command{
		Use:   "reboot",
		Short: "reboot",
	}
	root.AddCommand(rebootCmd)

	removeCmd := &cobra.Command{
		Use:   "remove",
		Short: "remove",
	}
	root.AddCommand(removeCmd)

	renameCmd := &cobra.Command{
		Use:   "rename",
		Short: "rename",
	}
	root.AddCommand(renameCmd)

	resizeCmd := &cobra.Command{
		Use:   "resize",
		Short: "resize",
	}
	root.AddCommand(resizeCmd)

	resumeCmd := &cobra.Command{
		Use:   "resume",
		Short: "resume",
	}
	root.AddCommand(resumeCmd)

	revertCmd := &cobra.Command{
		Use:   "revert",
		Short: "revert",
	}
	root.AddCommand(revertCmd)

	runCmd := &cobra.Command{
		Use:   "run",
		Short: "run",
	}
	root.AddCommand(runCmd)

	scaleCmd := &cobra.Command{
		Use:   "scale",
		Short: "scale",
	}
	root.AddCommand(scaleCmd)

	startCmd := &cobra.Command{
		Use:   "start",
		Short: "start",
	}
	root.AddCommand(startCmd)

	stopCmd := &cobra.Command{
		Use:   "stop",
		Short: "stop",
	}
	root.AddCommand(stopCmd)

	suspendCmd := &cobra.Command{
		Use:   "suspend",
		Short: "suspend",
	}
	root.AddCommand(suspendCmd)

	toggleCmd := &cobra.Command{
		Use:   "toggle",
		Short: "toggle",
	}
	root.AddCommand(toggleCmd)

	undefineCmd := &cobra.Command{
		Use:   "undefine",
		Short: "undefine",
	}
	root.AddCommand(undefineCmd)

	wait := &cobra.Command{
		Use:   "wait",
		Short: "Wait for a certain event or state before returning",
		Long:  "Blocks execution and uses polling to periodically check for a certain event or state before returning",
	}
	root.AddCommand(wait)

	func() {
		params := viper.New()
		cmd := &cobra.Command{
			Use:   "job-finished JOB-ID",
			Short: "Wait job",
			Long:  cli.Markdown("Wait until job finishes"),
			Args:  cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				if err := MistApiV2JobFinishedWaiter(args[0], params); err != nil {
					logger.Fatalf("Error waiting: %s", err.Error())
				}
			},
		}
		wait.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-clouds",
			Short:   "List clouds",
			Long:    cli.Markdown("List clouds owned by the active org. READ permission required on cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListClouds(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " add-cloud credentials{email: email, privateKey: privateKey, projectId: projectId}, name: my-cloud, provider: google\n"

		cmd := &cobra.Command{
			Use:     "add-cloud",
			Short:   "Add cloud",
			Long:    cli.Markdown("Adds a new cloud and returns the cloud's id. ADD permission required on cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddCloud(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "remove-cloud CLOUD",
			Short:   "Remove cloud",
			Long:    cli.Markdown("Remove target cloud"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RemoveCloud(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-cloud CLOUD",
			Short:   "Get cloud",
			Long:    cli.Markdown("Get details about target cloud"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetCloud(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " edit-cloud CLOUD name: my-renamed-cloud\n"

		cmd := &cobra.Command{
			Use:     "edit-cloud CLOUD",
			Short:   "Edit cloud",
			Long:    cli.Markdown("Update target cloud name or credentials"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditCloud(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-clusters",
			Short:   "List clusters",
			Long:    cli.Markdown("List clusters"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListClusters(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")
		cmd.Flags().Bool("credentials", false, "Return the cluster's credentials. Requires READ_CREDENTIALS permission on cluster. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create-cluster location: europe-west2-b, name: my-cluster, provider: google\n"

		cmd := &cobra.Command{
			Use:     "create-cluster",
			Short:   "Create cluster",
			Long:    cli.Markdown("Create a new cluster and return the cluster's id"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateCluster(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "destroy-cluster CLUSTER",
			Short:   "Destroy cluster",
			Long:    cli.Markdown("Destroy target clusters"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DestroyCluster(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-cluster CLUSTER",
			Short:   "Get cluster",
			Long:    cli.Markdown("Get details about target cluster"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetCluster(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().Bool("credentials", false, "Return the cluster's credentials. Requires READ_CREDENTIALS permission on cluster. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "scale-nodepool CLUSTER NODEPOOL",
			Short:   "Scale cluster nodepool",
			Long:    cli.Markdown("Scale the nodes of the specified nodepool"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[2:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2ScaleNodepool(args[0], args[1], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-datapoints QUERY",
			Short:   "Get datapoints",
			Long:    cli.Markdown("Get datapoints for a specific query"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetDatapoints(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("tags", "", "")
		cmd.Flags().String("search", "", "")
		cmd.Flags().String("start", "", "")
		cmd.Flags().String("end", "", "")
		cmd.Flags().String("step", "", "")
		cmd.Flags().String("time", "", "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-images",
			Short:   "List images",
			Long:    cli.Markdown("List images owned by the active org. READ permission required on image & cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListImages(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-image IMAGE",
			Short:   "Get image",
			Long:    cli.Markdown("Get details about target image"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetImage(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-job JOB-ID",
			Short:   "Get job",
			Long:    cli.Markdown(""),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetJob(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-keys",
			Short:   "List keys",
			Long:    cli.Markdown("List keys owned by the active org. READ permission required on key."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListKeys(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")
		cmd.Flags().Bool("private", false, "Return the private key. Requires READ_PRIVATE permission on key. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " add-key name: my-key, private: @file\n"

		cmd := &cobra.Command{
			Use:     "add-key",
			Short:   "Add key",
			Long:    cli.Markdown("Adds a new key and returns the key's id. ADD permission required on key."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddKey(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-key KEY",
			Short:   "Delete key",
			Long:    cli.Markdown("Delete target key"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteKey(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-key KEY",
			Short:   "Get key",
			Long:    cli.Markdown("Get details about target key"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetKey(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().Bool("private", false, "Return the private key. Requires READ_PRIVATE permission on key. (Only for single resource)")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-key KEY",
			Short:   "Edit key",
			Long:    cli.Markdown("Edit target key"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditKey(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("name", "", "New key name")
		cmd.Flags().Bool("default", false, "Set as default")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-locations",
			Short:   "List locations",
			Long:    cli.Markdown("List locations owned by the active org. READ permission required on location & cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListLocations(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-location LOCATION",
			Short:   "Get location",
			Long:    cli.Markdown("Get details about target location"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetLocation(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-machines",
			Short:   "List machines",
			Long:    cli.Markdown("List machines owned by the active org. READ permission required on machine & cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListMachines(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create-machine cloud: 6a760c7690dc4ac9913ce9b109aa900c, image: Ubuntu, name: testmachine, size{cpu: 2, memory: 2048}\n"

		examples += "  " + cli.Root.CommandPath() + " create-machine cloud: GCE, expiration{action: destroy, date: 2025-08-30T18:24:15Z}, image: Ubuntu, key: TestKey, location: us-east1-b, monitoring: true, name: testmachine, quantity: 2, schedules[]{datetime: 2023-09-22T18:19:28Z, schedule_type: one_off, script.script: test123}, scripts[].inline: @file, [].script: test123, size{cpu: 2, memory: 2048}\n"

		examples += "  " + cli.Root.CommandPath() + " create-machine image: Ubuntu, key: TestKey, monitoring: true, name: TestMachine, size{cpu: 1, memory: 1024}\n"

		examples += "  " + cli.Root.CommandPath() + " create-machine image: Ubuntu, name: awsmachine, provider: amazon, size: t3.micro\n"

		examples += "  " + cli.Root.CommandPath() + " create-machine image: Ubuntu, name: azuremachine, provider: azure, size: Standard_D4s_v5\n"

		examples += "  " + cli.Root.CommandPath() + " create-machine image: Ubuntu, name: gcemachine, provider: google, size: e2-medium\n"

		cmd := &cobra.Command{
			Use:     "create-machine",
			Short:   "Create machine",
			Long:    cli.Markdown("Creates one or more machines on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. READ permission required on location.\nCREATE_RESOURCES permission required on location. CREATE permission required on machine. RUN permission required on script. READ permission required on key.\n"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				resp, decoded, outputOptions, err := MistApiV2CreateMachine(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

				reqParams := params.AllSettings()

				var actual interface{}
				if params.GetBool("wait") {
					wparams := viper.New()
					actual, err = cli.GetMatchValue(resp.Context, "response.body#jobId", reqParams, decoded)
					if err != nil {
						logger.Fatalf("Could not get matcher value: %s", err.Error())
					}

					arg0 := fmt.Sprintf("%v", actual)

					if err := MistApiV2JobFinishedWaiter(arg0, wparams); err != nil {
						logger.Fatalf("Create machine failed: %s", err.Error())
					}

					fmt.Println("Create machine completed successfully")
				}
			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cmd.Flags().BoolP("wait", "w", false, "Wait job")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-machine MACHINE",
			Short:   "Get machine",
			Long:    cli.Markdown("Get details about target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-machine MACHINE",
			Short:   "Edit machine",
			Long:    cli.Markdown("Edit target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditMachine(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "associate-key MACHINE",
			Short:   "Associate a key with a machine",
			Long:    cli.Markdown("Associate a key with a machine."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AssociateKey(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "clone-machine MACHINE NAME",
			Short:   "Clone machine",
			Long:    cli.Markdown("Clone target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2CloneMachine(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().Bool("run-async", false, "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "destroy-machine MACHINE",
			Short:   "Destroy machine",
			Long:    cli.Markdown("Destroy target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DestroyMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "disassociate-key MACHINE",
			Short:   "Disassociate a key from a machine",
			Long:    cli.Markdown("Disassociate a key from a machine."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2DisassociateKey(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "reboot-machine MACHINE",
			Short:   "Reboot machine",
			Long:    cli.Markdown("Reboot target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RebootMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "rename-machine MACHINE NAME",
			Short:   "Rename machine",
			Long:    cli.Markdown("Rename target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RenameMachine(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "resize-machine MACHINE SIZE",
			Short:   "Resize machine",
			Long:    cli.Markdown("Resize target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ResizeMachine(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "resume-machine MACHINE",
			Short:   "Resume machine",
			Long:    cli.Markdown("Resume target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ResumeMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "start-machine MACHINE",
			Short:   "Start machine",
			Long:    cli.Markdown("Start target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2StartMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "stop-machine MACHINE",
			Short:   "Stop machine",
			Long:    cli.Markdown("Stop target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2StopMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "suspend-machine MACHINE",
			Short:   "Suspend machine",
			Long:    cli.Markdown("Suspend target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2SuspendMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "undefine-machine MACHINE",
			Short:   "Undefine machine",
			Long:    cli.Markdown("Undefine target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2UndefineMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().Bool("delete-domain-image", false, "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-snapshots MACHINE",
			Short:   "List machine snapshots",
			Long:    cli.Markdown("List snapshots of target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListSnapshots(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "create-snapshot MACHINE NAME",
			Short:   "Create snapshot",
			Long:    cli.Markdown("Create snapshots of target machine"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2CreateSnapshot(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "remove-snapshot MACHINE SNAPSHOT",
			Short:   "Remove snapshot",
			Long:    cli.Markdown("Remove target machine snapshot"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RemoveSnapshot(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "revert-to-snapshot MACHINE SNAPSHOT",
			Short:   "Revert to snapshot",
			Long:    cli.Markdown("Revert machine to snapshot"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RevertToSnapshot(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-networks",
			Short:   "List networks",
			Long:    cli.Markdown("List networks owned by the active org. READ permission required on network & cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListNetworks(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "create-network",
			Short:   "Create network",
			Long:    cli.Markdown("Creates one or more networks on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. CREATE permission required on network.\n"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateNetwork(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-network NETWORK CLOUD",
			Short:   "Delete network",
			Long:    cli.Markdown("Delete target network"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteNetwork(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-network NETWORK",
			Short:   "Get network",
			Long:    cli.Markdown("Get details about target network"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetNetwork(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-network NETWORK",
			Short:   "Edit network",
			Long:    cli.Markdown("Edit target network"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditNetwork(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("name", "", "New network name")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-rules",
			Short:   "List rules",
			Long:    cli.Markdown("Return a filtered list of rules"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListRules(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "add-rule",
			Short:   "Add rule",
			Long:    cli.Markdown("Add a new rule, READ permission required on target resource, ADD permission required on Rule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddRule(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-rule RULE",
			Short:   "Delete rule",
			Long:    cli.Markdown("Delete a rule given its UUID."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteRule(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-rule RULE",
			Short:   "Get rule",
			Long:    cli.Markdown("Get details about target rule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetRule(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("only", "", "Only return these fields")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "rename-rule RULE NAME",
			Short:   "Rename rule",
			Long:    cli.Markdown("Rename a rule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RenameRule(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-rule RULE",
			Short:   "Update rule",
			Long:    cli.Markdown("Edit a rule given its UUID, EDIT permission required on rule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditRule(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "toggle-rule RULE ACTION",
			Short:   "Toggle rule",
			Long:    cli.Markdown("Enable or disable a rule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ToggleRule(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-schedules",
			Short:   "List schedules",
			Long:    cli.Markdown("List schedules owned by the active org. READ permission required on schedules."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListSchedules(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " add-schedule action: reboot, description: This is a reboot machine schedule that runs once, enabled: true, name: TestMachineRebootSchedule, params: None, run_immediately: false, schedule_entry: 2022-06-05 00:00:00, schedule_type: one_off, selectors{ids: d5775984772949de820fa8279c306b30, type: machines}, start_after: 2022-06-08 00:00:00\n"

		cmd := &cobra.Command{
			Use:     "add-schedule",
			Short:   "Add schedule",
			Long:    cli.Markdown("Add schedule to user schedules"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddSchedule(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-schedule SCHEDULE",
			Short:   "Delete schedule",
			Long:    cli.Markdown("Delete target schedule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteSchedule(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-schedule SCHEDULE",
			Short:   "Get schedule",
			Long:    cli.Markdown("Get details about target schedule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetSchedule(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " edit-schedule SCHEDULE description: This is a deactivated schedule, enabled: false, name: DeactivatedSchedule\n"

		examples += "  " + cli.Root.CommandPath() + " edit-schedule SCHEDULE description: This is a renamed schedule, name: RenamedSchedule\n"

		cmd := &cobra.Command{
			Use:     "edit-schedule SCHEDULE",
			Short:   "Edit schedule",
			Long:    cli.Markdown("Edit target schedule"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditSchedule(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-scripts",
			Short:   "List scripts",
			Long:    cli.Markdown("List scripts owned by the active org. READ permission required on script."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListScripts(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "add-script",
			Short:   "Add script",
			Long:    cli.Markdown("Add script to user scripts"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddScript(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-script SCRIPT",
			Short:   "Delete script",
			Long:    cli.Markdown("Delete target script"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteScript(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-script SCRIPT",
			Short:   "Get script",
			Long:    cli.Markdown("Get details about target script"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetScript(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "run-script SCRIPT",
			Short:   "Run script",
			Long:    cli.Markdown("Start a script job to run the script."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2RunScript(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-script SCRIPT",
			Short:   "Edit script",
			Long:    cli.Markdown("Edit target script"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditScript(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("name", "", "New script name")
		cmd.Flags().String("description", "", "New script description")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "download-script SCRIPT",
			Short:   "Download script",
			Long:    cli.Markdown("Download script file or archive"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DownloadScript(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "generate-script-url SCRIPT",
			Short:   "Generate script url",
			Long:    cli.Markdown("Generate url for fetching script file"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GenerateScriptUrl(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-secrets",
			Short:   "List secrets",
			Long:    cli.Markdown("List secrets owned by the active org. READ permission required on secret."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListSecrets(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields (Only for listings)")
		cmd.Flags().Bool("value", false, "Return the secret's value. Requires READ_VALUE permission on secret. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "create-secret",
			Short:   "Create secret",
			Long:    cli.Markdown("Creates a new secret and returns the secret's id. CREATE permission required on secret."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateSecret(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-secret SECRET",
			Short:   "Delete secret",
			Long:    cli.Markdown("Delete target secret"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteSecret(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-secret SECRET",
			Short:   "Get secret",
			Long:    cli.Markdown("Read target secret"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetSecret(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().Bool("value", false, "Return the secret's value. Requires READ_VALUE permission on secret. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-secret SECRET",
			Short:   "Edit secret",
			Long:    cli.Markdown("Edit/update target secret"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditSecret(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-sizes",
			Short:   "List sizes",
			Long:    cli.Markdown("List sizes owned by the active org. READ permission required on size & cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListSizes(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-size SIZE",
			Short:   "Get size",
			Long:    cli.Markdown("Get details about target size"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetSize(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-tags",
			Short:   "List tags",
			Long:    cli.Markdown("List tags on resources owned by the active org. READ permission required on each resource."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListTags(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("types", "", "Choose resource types to by displayed")
		cmd.Flags().String("search", "", "Only return results matching search filter")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-users",
			Short:   "List users",
			Long:    cli.Markdown("Return current user if requester is not admin. Return all users for admin."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListUsers(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime.")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-volumes",
			Short:   "List volumes",
			Long:    cli.Markdown("List volumes owned by the active org. READ permission required on volume & cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListVolumes(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "create-volume",
			Short:   "Create volume",
			Long:    cli.Markdown("Creates one or more volumes on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. READ permission required on location.\nCREATE_RESOURCES permission required on location. CREATE permission required on volume.\n"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateVolume(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-volume VOLUME",
			Short:   "Delete volume",
			Long:    cli.Markdown("Delete target volume"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteVolume(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-volume VOLUME",
			Short:   "Get volume",
			Long:    cli.Markdown("Get details about target volume"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetVolume(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-volume VOLUME",
			Short:   "Edit volume",
			Long:    cli.Markdown("Edit target volume"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditVolume(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("name", "", "New volume name")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-zones",
			Short:   "List zones",
			Long:    cli.Markdown("List zones owned by the active org. READ permission required on zone & cloud."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListZones(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create-zone cloud: my-cloud, name: my-zone\n"

		cmd := &cobra.Command{
			Use:     "create-zone",
			Short:   "Create zone",
			Long:    cli.Markdown("Creates one or more zones on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. CREATE permission required on zone.\n"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateZone(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-zone ZONE",
			Short:   "Delete zone",
			Long:    cli.Markdown("Delete target zone"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteZone(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-zone ZONE",
			Short:   "Get zone",
			Long:    cli.Markdown("Get details about target zone"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetZone(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "edit-zone ZONE",
			Short:   "Edit zone",
			Long:    cli.Markdown("Edit target zone"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditZone(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "list-records ZONE",
			Short:   "List records",
			Long:    cli.Markdown("Lists all DNS records for a particular zone. READ permission required on zone and record."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListRecords(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create-record ZONE name: my-record, value: 123.23.23.2\n"

		cmd := &cobra.Command{
			Use:     "create-record ZONE",
			Short:   "Create record",
			Long:    cli.Markdown("Creates a new record under a specific zone. CREATE_RESOURCES permission required on cloud. CREATE_RECORDS permission required on zone"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateRecord(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "delete-record ZONE RECORD",
			Short:   "Delete record",
			Long:    cli.Markdown("Deletes a specific DNS record under a zone. REMOVE permission required on zone."),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteRecord(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use:     "get-record ZONE RECORD",
			Short:   "Get record",
			Long:    cli.Markdown("Get details about target record"),
			Hidden:  true,
			Example: examples,
			Args:    cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetRecord(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		root.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "cloud [CLOUD]",
			Aliases: []string{
				"clo",
				"clou",
				"clouds",
			},
			Short:   "List clouds",
			Long:    cli.Markdown("List clouds owned by the active org. READ permission required on cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListClouds(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetCloud(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListClouds(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clouds", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " add cloud credentials{email: email, privateKey: privateKey, projectId: projectId}, name: my-cloud, provider: google\n"

		cmd := &cobra.Command{
			Use: "cloud",
			Aliases: []string{
				"c",
				"cl",
				"clo",
				"clou",
				"clouds",
			},
			Short:   "Add cloud",
			Long:    cli.Markdown("Adds a new cloud and returns the cloud's id. ADD permission required on cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddCloud(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clouds", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		addCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "cloud CLOUD",
			Aliases: []string{
				"c",
				"cl",
				"clo",
				"clou",
				"clouds",
			},
			Short:   "Remove cloud",
			Long:    cli.Markdown("Remove target cloud"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListClouds(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RemoveCloud(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clouds/{cloud}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		removeCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " edit cloud CLOUD name: my-renamed-cloud\n"

		cmd := &cobra.Command{
			Use: "cloud CLOUD",
			Aliases: []string{
				"c",
				"cl",
				"clo",
				"clou",
				"clouds",
			},
			Short:   "Edit cloud",
			Long:    cli.Markdown("Update target cloud name or credentials"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListClouds(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditCloud(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clouds/{cloud}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "cluster [CLUSTER]",
			Aliases: []string{
				"clu",
				"clus",
				"clust",
				"cluste",
				"clusters",
			},
			Short:   "List clusters",
			Long:    cli.Markdown("List clusters"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListClusters(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetCluster(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListClusters(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clusters", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")
		cmd.Flags().Bool("credentials", false, "Return the cluster's credentials. Requires READ_CREDENTIALS permission on cluster. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create cluster location: europe-west2-b, name: my-cluster, provider: google\n"

		cmd := &cobra.Command{
			Use: "cluster",
			Aliases: []string{
				"c",
				"cl",
				"clu",
				"clus",
				"clust",
				"cluste",
				"clusters",
			},
			Short:   "Create cluster",
			Long:    cli.Markdown("Create a new cluster and return the cluster's id"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateCluster(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clusters", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "cluster CLUSTER",
			Aliases: []string{
				"c",
				"cl",
				"clu",
				"clus",
				"clust",
				"cluste",
				"clusters",
			},
			Short:   "Destroy cluster",
			Long:    cli.Markdown("Destroy target clusters"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListClusters(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DestroyCluster(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clusters/{cluster}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		destroyCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "nodepool CLUSTER NODEPOOL",
			Aliases: []string{
				"n",
				"no",
				"nod",
				"node",
				"nodep",
				"nodepo",
				"nodepoo",
				"nodepools",
			},
			Short:   "Scale cluster nodepool",
			Long:    cli.Markdown("Scale the nodes of the specified nodepool"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListClusters(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[2:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2ScaleNodepool(args[0], args[1], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/clusters/{cluster}/nodepools/{nodepool}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		scaleCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "datapoints QUERY",
			Aliases: []string{
				"d",
				"da",
				"dat",
				"data",
				"datap",
				"datapo",
				"datapoi",
				"datapoin",
				"datapoint",
			},
			Short:   "Get datapoints",
			Long:    cli.Markdown("Get datapoints for a specific query"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetDatapoints(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/datapoints", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("tags", "", "")
		cmd.Flags().String("search", "", "")
		cmd.Flags().String("start", "", "")
		cmd.Flags().String("end", "", "")
		cmd.Flags().String("step", "", "")
		cmd.Flags().String("time", "", "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "image [IMAGE]",
			Aliases: []string{
				"i",
				"im",
				"ima",
				"imag",
				"images",
			},
			Short:   "List images",
			Long:    cli.Markdown("List images owned by the active org. READ permission required on image & cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListImages(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetImage(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListImages(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/images", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "job JOB-ID",
			Aliases: []string{
				"j",
				"jo",
				"jobs",
			},
			Short:   "Get job",
			Long:    cli.Markdown(""),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GetJob(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/jobs/{job_id}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "key [KEY]",
			Aliases: []string{
				"k",
				"ke",
				"keys",
			},
			Short:   "List keys",
			Long:    cli.Markdown("List keys owned by the active org. READ permission required on key."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListKeys(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetKey(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListKeys(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/keys", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")
		cmd.Flags().Bool("private", false, "Return the private key. Requires READ_PRIVATE permission on key. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " add key name: my-key, private: @file\n"

		cmd := &cobra.Command{
			Use: "key",
			Aliases: []string{
				"k",
				"ke",
				"keys",
			},
			Short:   "Add key",
			Long:    cli.Markdown("Adds a new key and returns the key's id. ADD permission required on key."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddKey(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/keys", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		addCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "key KEY",
			Aliases: []string{
				"k",
				"ke",
				"keys",
			},
			Short:   "Delete key",
			Long:    cli.Markdown("Delete target key"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListKeys(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteKey(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/keys/{key}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "key KEY",
			Aliases: []string{
				"k",
				"ke",
				"keys",
			},
			Short:   "Edit key",
			Long:    cli.Markdown("Edit target key"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListKeys(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditKey(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/keys/{key}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)

		cmd.Flags().String("name", "", "New key name")
		cmd.Flags().Bool("default", false, "Set as default")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "location [LOCATION]",
			Aliases: []string{
				"l",
				"lo",
				"loc",
				"loca",
				"locat",
				"locati",
				"locatio",
				"locations",
			},
			Short:   "List locations",
			Long:    cli.Markdown("List locations owned by the active org. READ permission required on location & cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListLocations(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetLocation(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListLocations(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/locations", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine [MACHINE]",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "List machines",
			Long:    cli.Markdown("List machines owned by the active org. READ permission required on machine & cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetMachine(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create machine cloud: 6a760c7690dc4ac9913ce9b109aa900c, image: Ubuntu, name: testmachine, size{cpu: 2, memory: 2048}\n"

		examples += "  " + cli.Root.CommandPath() + " create machine cloud: GCE, expiration{action: destroy, date: 2025-08-30T18:24:15Z}, image: Ubuntu, key: TestKey, location: us-east1-b, monitoring: true, name: testmachine, quantity: 2, schedules[]{datetime: 2023-09-22T18:19:28Z, schedule_type: one_off, script.script: test123}, scripts[].inline: @file, [].script: test123, size{cpu: 2, memory: 2048}\n"

		examples += "  " + cli.Root.CommandPath() + " create machine image: Ubuntu, key: TestKey, monitoring: true, name: TestMachine, size{cpu: 1, memory: 1024}\n"

		examples += "  " + cli.Root.CommandPath() + " create machine image: Ubuntu, name: awsmachine, provider: amazon, size: t3.micro\n"

		examples += "  " + cli.Root.CommandPath() + " create machine image: Ubuntu, name: azuremachine, provider: azure, size: Standard_D4s_v5\n"

		examples += "  " + cli.Root.CommandPath() + " create machine image: Ubuntu, name: gcemachine, provider: google, size: e2-medium\n"

		cmd := &cobra.Command{
			Use: "machine",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Create machine",
			Long:    cli.Markdown("Creates one or more machines on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. READ permission required on location.\nCREATE_RESOURCES permission required on location. CREATE permission required on machine. RUN permission required on script. READ permission required on key.\n"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				resp, decoded, outputOptions, err := MistApiV2CreateMachine(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

				reqParams := params.AllSettings()

				var actual interface{}
				if params.GetBool("wait") {
					wparams := viper.New()
					actual, err = cli.GetMatchValue(resp.Context, "response.body#jobId", reqParams, decoded)
					if err != nil {
						logger.Fatalf("Could not get matcher value: %s", err.Error())
					}

					arg0 := fmt.Sprintf("%v", actual)

					if err := MistApiV2JobFinishedWaiter(arg0, wparams); err != nil {
						logger.Fatalf("Waiter error: %s", err.Error())
					}

					fmt.Println("Create machine completed successfully")
				}
			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cmd.Flags().BoolP("wait", "w", false, "Wait job")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Edit machine",
			Long:    cli.Markdown("Edit target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditMachine(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "key MACHINE",
			Aliases: []string{
				"k",
				"ke",
				"keys",
			},
			Short:   "Associate a key with a machine",
			Long:    cli.Markdown("Associate a key with a machine."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AssociateKey(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/associate-key", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		associateCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE NAME",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Clone machine",
			Long:    cli.Markdown("Clone target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2CloneMachine(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/clone", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		cloneCmd.AddCommand(cmd)

		cmd.Flags().Bool("run-async", false, "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Destroy machine",
			Long:    cli.Markdown("Destroy target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DestroyMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/destroy", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		destroyCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "key MACHINE",
			Aliases: []string{
				"k",
				"ke",
				"keys",
			},
			Short:   "Disassociate a key from a machine",
			Long:    cli.Markdown("Disassociate a key from a machine."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2DisassociateKey(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/disassociate-key", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		disassociateCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Reboot machine",
			Long:    cli.Markdown("Reboot target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RebootMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/reboot", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		rebootCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE NAME",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Rename machine",
			Long:    cli.Markdown("Rename target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RenameMachine(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/rename", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		renameCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE SIZE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Resize machine",
			Long:    cli.Markdown("Resize target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				if len(args) == 1 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSizes(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ResizeMachine(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/resize", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		resizeCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Resume machine",
			Long:    cli.Markdown("Resume target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ResumeMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/resume", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		resumeCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Start machine",
			Long:    cli.Markdown("Start target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2StartMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/start", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		startCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Stop machine",
			Long:    cli.Markdown("Stop target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2StopMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/stop", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		stopCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Suspend machine",
			Long:    cli.Markdown("Suspend target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2SuspendMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/suspend", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		suspendCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "machine MACHINE",
			Aliases: []string{
				"m",
				"ma",
				"mac",
				"mach",
				"machi",
				"machin",
				"machines",
			},
			Short:   "Undefine machine",
			Long:    cli.Markdown("Undefine target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2UndefineMachine(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/actions/undefine", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		undefineCmd.AddCommand(cmd)

		cmd.Flags().Bool("delete-domain-image", false, "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "snapshots MACHINE",
			Aliases: []string{
				"sn",
				"sna",
				"snap",
				"snaps",
				"snapsh",
				"snapsho",
				"snapshots",
			},
			Short:   "List machine snapshots",
			Long:    cli.Markdown("List snapshots of target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListSnapshots(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/snapshots", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "snapshot MACHINE NAME",
			Aliases: []string{
				"sn",
				"sna",
				"snap",
				"snaps",
				"snapsh",
				"snapsho",
				"snapshots",
			},
			Short:   "Create snapshot",
			Long:    cli.Markdown("Create snapshots of target machine"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2CreateSnapshot(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/snapshots", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "snapshot MACHINE SNAPSHOT",
			Aliases: []string{
				"s",
				"sn",
				"sna",
				"snap",
				"snaps",
				"snapsh",
				"snapsho",
				"snapshots",
			},
			Short:   "Remove snapshot",
			Long:    cli.Markdown("Remove target machine snapshot"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				if len(args) == 1 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSnapshots(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RemoveSnapshot(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/snapshots/{snapshot}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		removeCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "to-snapshot MACHINE SNAPSHOT",
			Aliases: []string{
				"t",
				"to",
				"to-",
				"to-s",
				"to-sn",
				"to-sna",
				"to-snap",
				"to-snaps",
				"to-snapsh",
				"to-snapsho",
				"to-snapshots",
			},
			Short:   "Revert to snapshot",
			Long:    cli.Markdown("Revert machine to snapshot"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListMachines(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				if len(args) == 1 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSnapshots(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RevertToSnapshot(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/machines/{machine}/snapshots/{snapshot}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		revertCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "network [NETWORK]",
			Aliases: []string{
				"n",
				"ne",
				"net",
				"netw",
				"netwo",
				"networ",
				"networks",
			},
			Short:   "List networks",
			Long:    cli.Markdown("List networks owned by the active org. READ permission required on network & cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListNetworks(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetNetwork(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListNetworks(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/networks", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "network",
			Aliases: []string{
				"n",
				"ne",
				"net",
				"netw",
				"netwo",
				"networ",
				"networks",
			},
			Short:   "Create network",
			Long:    cli.Markdown("Creates one or more networks on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. CREATE permission required on network.\n"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateNetwork(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/networks", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "network NETWORK CLOUD",
			Aliases: []string{
				"n",
				"ne",
				"net",
				"netw",
				"netwo",
				"networ",
				"networks",
			},
			Short:   "Delete network",
			Long:    cli.Markdown("Delete target network"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListNetworks(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				if len(args) == 1 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListClouds(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteNetwork(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/networks/{network}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "network NETWORK",
			Aliases: []string{
				"n",
				"ne",
				"net",
				"netw",
				"netwo",
				"networ",
				"networks",
			},
			Short:   "Edit network",
			Long:    cli.Markdown("Edit target network"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListNetworks(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditNetwork(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/networks/{network}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)

		cmd.Flags().String("name", "", "New network name")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "rule [RULE]",
			Aliases: []string{
				"ru",
				"rul",
				"rules",
			},
			Short:   "List rules",
			Long:    cli.Markdown("Return a filtered list of rules"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListRules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetRule(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListRules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/rules", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "rule",
			Aliases: []string{
				"r",
				"ru",
				"rul",
				"rules",
			},
			Short:   "Add rule",
			Long:    cli.Markdown("Add a new rule, READ permission required on target resource, ADD permission required on Rule"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddRule(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/rules", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		addCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "rule RULE",
			Aliases: []string{
				"ru",
				"rul",
				"rules",
			},
			Short:   "Delete rule",
			Long:    cli.Markdown("Delete a rule given its UUID."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListRules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteRule(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/rules/{rule}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "rule RULE NAME",
			Aliases: []string{
				"r",
				"ru",
				"rul",
				"rules",
			},
			Short:   "Rename rule",
			Long:    cli.Markdown("Rename a rule"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListRules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2RenameRule(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Patch") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/rules/{rule}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		renameCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "rule RULE",
			Aliases: []string{
				"r",
				"ru",
				"rul",
				"rules",
			},
			Short:   "Update rule",
			Long:    cli.Markdown("Edit a rule given its UUID, EDIT permission required on rule"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListRules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditRule(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/rules/{rule}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "rule RULE ACTION",
			Aliases: []string{
				"r",
				"ru",
				"rul",
				"rules",
			},
			Short:   "Toggle rule",
			Long:    cli.Markdown("Enable or disable a rule"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListRules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ToggleRule(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/rules/{rule}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		toggleCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "schedule [SCHEDULE]",
			Aliases: []string{
				"sch",
				"sche",
				"sched",
				"schedu",
				"schedul",
				"schedules",
			},
			Short:   "List schedules",
			Long:    cli.Markdown("List schedules owned by the active org. READ permission required on schedules."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSchedules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetSchedule(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListSchedules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/schedules", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " add schedule action: reboot, description: This is a reboot machine schedule that runs once, enabled: true, name: TestMachineRebootSchedule, params: None, run_immediately: false, schedule_entry: 2022-06-05 00:00:00, schedule_type: one_off, selectors{ids: d5775984772949de820fa8279c306b30, type: machines}, start_after: 2022-06-08 00:00:00\n"

		cmd := &cobra.Command{
			Use: "schedule",
			Aliases: []string{
				"sch",
				"sche",
				"sched",
				"schedu",
				"schedul",
				"schedules",
			},
			Short:   "Add schedule",
			Long:    cli.Markdown("Add schedule to user schedules"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddSchedule(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/schedules", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		addCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "schedule SCHEDULE",
			Aliases: []string{
				"sch",
				"sche",
				"sched",
				"schedu",
				"schedul",
				"schedules",
			},
			Short:   "Delete schedule",
			Long:    cli.Markdown("Delete target schedule"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSchedules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteSchedule(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/schedules/{schedule}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " edit schedule SCHEDULE description: This is a deactivated schedule, enabled: false, name: DeactivatedSchedule\n"

		examples += "  " + cli.Root.CommandPath() + " edit schedule SCHEDULE description: This is a renamed schedule, name: RenamedSchedule\n"

		cmd := &cobra.Command{
			Use: "schedule SCHEDULE",
			Aliases: []string{
				"sch",
				"sche",
				"sched",
				"schedu",
				"schedul",
				"schedules",
			},
			Short:   "Edit schedule",
			Long:    cli.Markdown("Edit target schedule"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSchedules(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditSchedule(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Patch") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/schedules/{schedule}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "script [SCRIPT]",
			Aliases: []string{
				"scr",
				"scri",
				"scrip",
				"scripts",
			},
			Short:   "List scripts",
			Long:    cli.Markdown("List scripts owned by the active org. READ permission required on script."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListScripts(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetScript(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListScripts(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/scripts", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "script",
			Aliases: []string{
				"scr",
				"scri",
				"scrip",
				"scripts",
			},
			Short:   "Add script",
			Long:    cli.Markdown("Add script to user scripts"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2AddScript(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/scripts", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		addCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "script SCRIPT",
			Aliases: []string{
				"scr",
				"scri",
				"scrip",
				"scripts",
			},
			Short:   "Delete script",
			Long:    cli.Markdown("Delete target script"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListScripts(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteScript(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/scripts/{script}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "script SCRIPT",
			Aliases: []string{
				"s",
				"sc",
				"scr",
				"scri",
				"scrip",
				"scripts",
			},
			Short:   "Run script",
			Long:    cli.Markdown("Start a script job to run the script."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListScripts(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2RunScript(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/scripts/{script}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		runCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "script SCRIPT",
			Aliases: []string{
				"scr",
				"scri",
				"scrip",
				"scripts",
			},
			Short:   "Edit script",
			Long:    cli.Markdown("Edit target script"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListScripts(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditScript(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/scripts/{script}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)

		cmd.Flags().String("name", "", "New script name")
		cmd.Flags().String("description", "", "New script description")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "script SCRIPT",
			Aliases: []string{
				"s",
				"sc",
				"scr",
				"scri",
				"scrip",
				"scripts",
			},
			Short:   "Download script",
			Long:    cli.Markdown("Download script file or archive"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListScripts(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DownloadScript(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/scripts/{script}/file", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		downloadCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "script-url SCRIPT",
			Aliases: []string{
				"s",
				"sc",
				"scr",
				"scri",
				"scrip",
				"script",
				"script-",
				"script-u",
				"script-ur",
				"script-urls",
			},
			Short:   "Generate script url",
			Long:    cli.Markdown("Generate url for fetching script file"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListScripts(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2GenerateScriptUrl(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/scripts/{script}/url", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		generateCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "secret [SECRET]",
			Aliases: []string{
				"se",
				"sec",
				"secr",
				"secre",
				"secrets",
			},
			Short:   "List secrets",
			Long:    cli.Markdown("List secrets owned by the active org. READ permission required on secret."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSecrets(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetSecret(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListSecrets(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/secrets", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields (Only for listings)")
		cmd.Flags().Bool("value", false, "Return the secret's value. Requires READ_VALUE permission on secret. (Only for single resource)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "secret",
			Aliases: []string{
				"se",
				"sec",
				"secr",
				"secre",
				"secrets",
			},
			Short:   "Create secret",
			Long:    cli.Markdown("Creates a new secret and returns the secret's id. CREATE permission required on secret."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateSecret(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/secrets", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "secret SECRET",
			Aliases: []string{
				"se",
				"sec",
				"secr",
				"secre",
				"secrets",
			},
			Short:   "Delete secret",
			Long:    cli.Markdown("Delete target secret"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSecrets(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteSecret(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/secrets/{secret}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "secret SECRET",
			Aliases: []string{
				"se",
				"sec",
				"secr",
				"secre",
				"secrets",
			},
			Short:   "Edit secret",
			Long:    cli.Markdown("Edit/update target secret"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSecrets(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2EditSecret(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/secrets/{secret}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "size [SIZE]",
			Aliases: []string{
				"si",
				"siz",
				"sizes",
			},
			Short:   "List sizes",
			Long:    cli.Markdown("List sizes owned by the active org. READ permission required on size & cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListSizes(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetSize(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListSizes(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/sizes", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "tag",
			Aliases: []string{
				"t",
				"ta",
				"tags",
			},
			Short:   "List tags",
			Long:    cli.Markdown("List tags on resources owned by the active org. READ permission required on each resource."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListTags(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/tags", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("types", "", "Choose resource types to by displayed")
		cmd.Flags().String("search", "", "Only return results matching search filter")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "user",
			Aliases: []string{
				"u",
				"us",
				"use",
				"users",
			},
			Short:   "List users",
			Long:    cli.Markdown("Return current user if requester is not admin. Return all users for admin."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2ListUsers(params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/users", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("search", "", "Only return results matching search filter")
		cmd.Flags().String("sort", "", "Order results by")
		cmd.Flags().String("start", "", "Start results from index or id")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime.")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "volume [VOLUME]",
			Aliases: []string{
				"v",
				"vo",
				"vol",
				"volu",
				"volum",
				"volumes",
			},
			Short:   "List volumes",
			Long:    cli.Markdown("List volumes owned by the active org. READ permission required on volume & cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListVolumes(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetVolume(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListVolumes(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/volumes", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "volume",
			Aliases: []string{
				"v",
				"vo",
				"vol",
				"volu",
				"volum",
				"volumes",
			},
			Short:   "Create volume",
			Long:    cli.Markdown("Creates one or more volumes on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. READ permission required on location.\nCREATE_RESOURCES permission required on location. CREATE permission required on volume.\n"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateVolume(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/volumes", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "volume VOLUME",
			Aliases: []string{
				"v",
				"vo",
				"vol",
				"volu",
				"volum",
				"volumes",
			},
			Short:   "Delete volume",
			Long:    cli.Markdown("Delete target volume"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListVolumes(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteVolume(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/volumes/{volume}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "volume VOLUME",
			Aliases: []string{
				"v",
				"vo",
				"vol",
				"volu",
				"volum",
				"volumes",
			},
			Short:   "Edit volume",
			Long:    cli.Markdown("Edit target volume"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListVolumes(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditVolume(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/volumes/{volume}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)

		cmd.Flags().String("name", "", "New volume name")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "zone [ZONE]",
			Aliases: []string{
				"z",
				"zo",
				"zon",
				"zones",
			},
			Short:   "List zones",
			Long:    cli.Markdown("List zones owned by the active org. READ permission required on zone & cloud."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListZones(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetZone(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListZones(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/zones", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "(Only for listings)")
		cmd.Flags().String("search", "", "Only return results matching search filter (Only for listings)")
		cmd.Flags().String("sort", "", "Order results by (Only for listings)")
		cmd.Flags().String("start", "", "Start results from index or id (Only for listings)")
		cmd.Flags().Int64("limit", 0, "Limit number of results, 1000 max (Only for listings)")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")
		cmd.Flags().String("at", "", "Limit results by specific datetime. Return resources created before or at, or deleted after or at, given datetime. (Only for listings)")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create zone cloud: my-cloud, name: my-zone\n"

		cmd := &cobra.Command{
			Use: "zone",
			Aliases: []string{
				"z",
				"zo",
				"zon",
				"zones",
			},
			Short:   "Create zone",
			Long:    cli.Markdown("Creates one or more zones on the specified cloud. If async is true, a jobId will be returned.\nREAD permission required on cloud. CREATE_RESOURCES permission required on cloud. CREATE permission required on zone.\n"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(0),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[0:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateZone(params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/zones", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "zone ZONE",
			Aliases: []string{
				"z",
				"zo",
				"zon",
				"zones",
			},
			Short:   "Delete zone",
			Long:    cli.Markdown("Delete target zone"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListZones(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteZone(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/zones/{zone}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "zone ZONE",
			Aliases: []string{
				"z",
				"zo",
				"zon",
				"zones",
			},
			Short:   "Edit zone",
			Long:    cli.Markdown("Edit target zone"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListZones(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2EditZone(args[0], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Put") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/zones/{zone}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		editCmd.AddCommand(cmd)

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "records ZONE [RECORD]",
			Aliases: []string{
				"re",
				"rec",
				"reco",
				"recor",
				"records",
			},
			Short:   "List records",
			Long:    cli.Markdown("Lists all DNS records for a particular zone. READ permission required on zone and record."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
				if len(args) == 0 {
					params := viper.New()
					params.Set("search", toComplete)
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListRecords(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},

			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				if len(args) == 1 {

					_, decoded, outputOptions, err := MistApiV2GetRecord(args[0], args[1], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				} else if len(args) == 0 {

					_, decoded, outputOptions, err := MistApiV2ListRecords(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
						logger.Fatalf("Formatting failed: %s", err.Error())
					}
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Get") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/zones/{zone}/records", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		getCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "")
		cmd.Flags().String("only", "", "Only return these fields")
		cmd.Flags().String("deref", "", "Dereference foreign keys")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		examples += "  " + cli.Root.CommandPath() + " create record ZONE name: my-record, value: 123.23.23.2\n"

		cmd := &cobra.Command{
			Use: "record ZONE",
			Aliases: []string{
				"r",
				"re",
				"rec",
				"reco",
				"recor",
				"records",
			},
			Short:   "Create record",
			Long:    cli.Markdown("Creates a new record under a specific zone. CREATE_RESOURCES permission required on cloud. CREATE_RECORDS permission required on zone"),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListZones(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(1),
			Run: func(cmd *cobra.Command, args []string) {
				body, err := cli.GetBody("application/json", args[1:], params.GetString("filename"))
				if err != nil {
					logger.Fatalf("Unable to get body: %s", err.Error())
				}

				_, decoded, outputOptions, err := MistApiV2CreateRecord(args[0], params, body)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Post") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/zones/{zone}/records", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		createCmd.AddCommand(cmd)
		cmd.Flags().StringP("filename", "f", "", "Filename")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

	func() {
		params := viper.New()

		var examples string

		cmd := &cobra.Command{
			Use: "record ZONE RECORD",
			Aliases: []string{
				"re",
				"rec",
				"reco",
				"recor",
				"records",
			},
			Short:   "Delete record",
			Long:    cli.Markdown("Deletes a specific DNS record under a zone. REMOVE permission required on zone."),
			Example: examples,
			ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

				if len(args) == 0 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListZones(params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}

				if len(args) == 1 {
					params := viper.New()
					params.Set("only", "name")
					var decoded interface{}
					_, decoded, _, err := MistApiV2ListRecords(args[0], params)
					if err != nil {
						logger.Fatalf("Error calling operation: %s", err.Error())
					}
					data, _ := jmespath.Search("data[].name", decoded)
					j, _ := json.Marshal(data)
					str := strings.Replace(strings.Replace(strings.Replace(string(j[:]), "[", "", -1), "]", "", -1), " ", "\\ ", -1)
					return strings.Split(str, ","), cobra.ShellCompDirectiveNoFileComp
				}
				return nil, cobra.ShellCompDirectiveNoFileComp
			},
			Args: cobra.MinimumNArgs(2),
			Run: func(cmd *cobra.Command, args []string) {

				_, decoded, outputOptions, err := MistApiV2DeleteRecord(args[0], args[1], params)
				if err != nil {
					logger.Fatalf("Error calling operation: %s", err.Error())
				}

				if err := cli.Formatter.Format(decoded, params, outputOptions); err != nil {
					logger.Fatalf("Formatting failed: %s", err.Error())
				}

			},
		}
		cmd.SetErr(os.Stderr)
		cmd.SetUsageTemplate("/api/v2#" + strings.ToLower("Delete") + "-" + strings.ReplaceAll(strings.ReplaceAll("/api/v2/zones/{zone}/records/{record}", "{", "-"), "}", "-"))
		cmd.SetUsageFunc(customUsageFunc)
		deleteCmd.AddCommand(cmd)

		cmd.Flags().String("cloud", "", "")

		cli.SetCustomFlags(cmd)

		if cmd.Flags().HasFlags() {
			params.BindPFlags(cmd.Flags())
		}

	}()

}