Update Rancher API integration to go-rancher client v2.

vendor/github.com/rancher/go-rancher/v2/client.go

@@ -0,0 +1,39 @@
+package client
+
+import (
+	"net/http"
+
+	"github.com/gorilla/websocket"
+)
+
+type RancherBaseClientImpl struct {
+	Opts    *ClientOpts
+	Schemas *Schemas
+	Types   map[string]Schema
+}
+
+type RancherBaseClient interface {
+	Websocket(string, map[string][]string) (*websocket.Conn, *http.Response, error)
+	List(string, *ListOpts, interface{}) error
+	Post(string, interface{}, interface{}) error
+	GetLink(Resource, string, interface{}) error
+	Create(string, interface{}, interface{}) error
+	Update(string, *Resource, interface{}, interface{}) error
+	ById(string, string, interface{}) error
+	Delete(*Resource) error
+	Reload(*Resource, interface{}) error
+	Action(string, string, *Resource, interface{}, interface{}) error
+	GetOpts() *ClientOpts
+	GetSchemas() *Schemas
+	GetTypes() map[string]Schema
+
+	doGet(string, *ListOpts, interface{}) error
+	doList(string, *ListOpts, interface{}) error
+	doNext(string, interface{}) error
+	doModify(string, string, interface{}, interface{}) error
+	doCreate(string, interface{}, interface{}) error
+	doUpdate(string, *Resource, interface{}, interface{}) error
+	doById(string, string, interface{}) error
+	doResourceDelete(string, *Resource) error
+	doAction(string, string, *Resource, interface{}, interface{}) error
+}

vendor/github.com/rancher/go-rancher/v2/common.go

@@ -0,0 +1,620 @@
+package client
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/pkg/errors"
+)
+
+const (
+	SELF       = "self"
+	COLLECTION = "collection"
+)
+
+var (
+	debug             = false
+	dialer            = &websocket.Dialer{}
+	privateFieldRegex = regexp.MustCompile("^[[:lower:]]")
+)
+
+type ClientOpts struct {
+	Url       string
+	AccessKey string
+	SecretKey string
+	Timeout   time.Duration
+}
+
+type ApiError struct {
+	StatusCode int
+	Url        string
+	Msg        string
+	Status     string
+	Body       string
+}
+
+func (e *ApiError) Error() string {
+	return e.Msg
+}
+
+func IsNotFound(err error) bool {
+	apiError, ok := err.(*ApiError)
+	if !ok {
+		return false
+	}
+
+	return apiError.StatusCode == http.StatusNotFound
+}
+
+func newApiError(resp *http.Response, url string) *ApiError {
+	contents, err := ioutil.ReadAll(resp.Body)
+	var body string
+	if err != nil {
+		body = "Unreadable body."
+	} else {
+		body = string(contents)
+	}
+
+	data := map[string]interface{}{}
+	if json.Unmarshal(contents, &data) == nil {
+		delete(data, "id")
+		delete(data, "links")
+		delete(data, "actions")
+		delete(data, "type")
+		delete(data, "status")
+		buf := &bytes.Buffer{}
+		for k, v := range data {
+			if v == nil {
+				continue
+			}
+			if buf.Len() > 0 {
+				buf.WriteString(", ")
+			}
+			fmt.Fprintf(buf, "%s=%v", k, v)
+		}
+		body = buf.String()
+	}
+	formattedMsg := fmt.Sprintf("Bad response statusCode [%d]. Status [%s]. Body: [%s] from [%s]",
+		resp.StatusCode, resp.Status, body, url)
+	return &ApiError{
+		Url:        url,
+		Msg:        formattedMsg,
+		StatusCode: resp.StatusCode,
+		Status:     resp.Status,
+		Body:       body,
+	}
+}
+
+func contains(array []string, item string) bool {
+	for _, check := range array {
+		if check == item {
+			return true
+		}
+	}
+
+	return false
+}
+
+func appendFilters(urlString string, filters map[string]interface{}) (string, error) {
+	if len(filters) == 0 {
+		return urlString, nil
+	}
+
+	u, err := url.Parse(urlString)
+	if err != nil {
+		return "", err
+	}
+
+	q := u.Query()
+	for k, v := range filters {
+		if l, ok := v.([]string); ok {
+			for _, v := range l {
+				q.Add(k, v)
+			}
+		} else {
+			q.Add(k, fmt.Sprintf("%v", v))
+		}
+	}
+
+	u.RawQuery = q.Encode()
+	return u.String(), nil
+}
+
+func NormalizeUrl(existingUrl string) (string, error) {
+	u, err := url.Parse(existingUrl)
+	if err != nil {
+		return "", err
+	}
+
+	if u.Path == "" || u.Path == "/" {
+		u.Path = "v2-beta"
+	} else if u.Path == "/v1" || strings.HasPrefix(u.Path, "/v1/") {
+		u.Path = strings.Replace(u.Path, "/v1", "/v2-beta", 1)
+	}
+
+	return u.String(), nil
+}
+
+func setupRancherBaseClient(rancherClient *RancherBaseClientImpl, opts *ClientOpts) error {
+	var err error
+	opts.Url, err = NormalizeUrl(opts.Url)
+	if err != nil {
+		return err
+	}
+
+	if opts.Timeout == 0 {
+		opts.Timeout = time.Second * 10
+	}
+	client := &http.Client{Timeout: opts.Timeout}
+	req, err := http.NewRequest("GET", opts.Url, nil)
+	if err != nil {
+		return err
+	}
+
+	req.SetBasicAuth(opts.AccessKey, opts.SecretKey)
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return newApiError(resp, opts.Url)
+	}
+
+	schemasUrls := resp.Header.Get("X-API-Schemas")
+	if len(schemasUrls) == 0 {
+		return errors.New("Failed to find schema at [" + opts.Url + "]")
+	}
+
+	if schemasUrls != opts.Url {
+		req, err = http.NewRequest("GET", schemasUrls, nil)
+		req.SetBasicAuth(opts.AccessKey, opts.SecretKey)
+		if err != nil {
+			return err
+		}
+
+		resp, err = client.Do(req)
+		if err != nil {
+			return err
+		}
+
+		defer resp.Body.Close()
+
+		if resp.StatusCode != 200 {
+			return newApiError(resp, opts.Url)
+		}
+	}
+
+	var schemas Schemas
+	bytes, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	err = json.Unmarshal(bytes, &schemas)
+	if err != nil {
+		return err
+	}
+
+	rancherClient.Opts = opts
+	rancherClient.Schemas = &schemas
+
+	for _, schema := range schemas.Data {
+		rancherClient.Types[schema.Id] = schema
+	}
+
+	return nil
+}
+
+func NewListOpts() *ListOpts {
+	return &ListOpts{
+		Filters: map[string]interface{}{},
+	}
+}
+
+func (rancherClient *RancherBaseClientImpl) setupRequest(req *http.Request) {
+	req.SetBasicAuth(rancherClient.Opts.AccessKey, rancherClient.Opts.SecretKey)
+}
+
+func (rancherClient *RancherBaseClientImpl) newHttpClient() *http.Client {
+	if rancherClient.Opts.Timeout == 0 {
+		rancherClient.Opts.Timeout = time.Second * 10
+	}
+	return &http.Client{Timeout: rancherClient.Opts.Timeout}
+}
+
+func (rancherClient *RancherBaseClientImpl) doDelete(url string) error {
+	client := rancherClient.newHttpClient()
+	req, err := http.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return err
+	}
+
+	rancherClient.setupRequest(req)
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	io.Copy(ioutil.Discard, resp.Body)
+
+	if resp.StatusCode >= 300 {
+		return newApiError(resp, url)
+	}
+
+	return nil
+}
+
+func (rancherClient *RancherBaseClientImpl) Websocket(url string, headers map[string][]string) (*websocket.Conn, *http.Response, error) {
+	httpHeaders := http.Header{}
+	for k, v := range httpHeaders {
+		httpHeaders[k] = v
+	}
+
+	if rancherClient.Opts != nil {
+		s := rancherClient.Opts.AccessKey + ":" + rancherClient.Opts.SecretKey
+		httpHeaders.Add("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(s)))
+	}
+
+	return dialer.Dial(url, http.Header(httpHeaders))
+}
+
+func (rancherClient *RancherBaseClientImpl) doGet(url string, opts *ListOpts, respObject interface{}) error {
+	if opts == nil {
+		opts = NewListOpts()
+	}
+	url, err := appendFilters(url, opts.Filters)
+	if err != nil {
+		return err
+	}
+
+	if debug {
+		fmt.Println("GET " + url)
+	}
+
+	client := rancherClient.newHttpClient()
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return err
+	}
+
+	rancherClient.setupRequest(req)
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return newApiError(resp, url)
+	}
+
+	byteContent, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if debug {
+		fmt.Println("Response <= " + string(byteContent))
+	}
+
+	if err := json.Unmarshal(byteContent, respObject); err != nil {
+		return errors.Wrap(err, fmt.Sprintf("Failed to parse: %s", byteContent))
+	}
+
+	return nil
+}
+
+func (rancherClient *RancherBaseClientImpl) List(schemaType string, opts *ListOpts, respObject interface{}) error {
+	return rancherClient.doList(schemaType, opts, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) doList(schemaType string, opts *ListOpts, respObject interface{}) error {
+	schema, ok := rancherClient.Types[schemaType]
+	if !ok {
+		return errors.New("Unknown schema type [" + schemaType + "]")
+	}
+
+	if !contains(schema.CollectionMethods, "GET") {
+		return errors.New("Resource type [" + schemaType + "] is not listable")
+	}
+
+	collectionUrl, ok := schema.Links[COLLECTION]
+	if !ok {
+		return errors.New("Failed to find collection URL for [" + schemaType + "]")
+	}
+
+	return rancherClient.doGet(collectionUrl, opts, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) doNext(nextUrl string, respObject interface{}) error {
+	return rancherClient.doGet(nextUrl, nil, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) Post(url string, createObj interface{}, respObject interface{}) error {
+	return rancherClient.doModify("POST", url, createObj, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) GetLink(resource Resource, link string, respObject interface{}) error {
+	url := resource.Links[link]
+	if url == "" {
+		return fmt.Errorf("Failed to find link: %s", link)
+	}
+
+	return rancherClient.doGet(url, &ListOpts{}, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) doModify(method string, url string, createObj interface{}, respObject interface{}) error {
+	bodyContent, err := json.Marshal(createObj)
+	if err != nil {
+		return err
+	}
+
+	if debug {
+		fmt.Println(method + " " + url)
+		fmt.Println("Request => " + string(bodyContent))
+	}
+
+	client := rancherClient.newHttpClient()
+	req, err := http.NewRequest(method, url, bytes.NewBuffer(bodyContent))
+	if err != nil {
+		return err
+	}
+
+	rancherClient.setupRequest(req)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 300 {
+		return newApiError(resp, url)
+	}
+
+	byteContent, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if len(byteContent) > 0 {
+		if debug {
+			fmt.Println("Response <= " + string(byteContent))
+		}
+		return json.Unmarshal(byteContent, respObject)
+	}
+
+	return nil
+}
+
+func (rancherClient *RancherBaseClientImpl) Create(schemaType string, createObj interface{}, respObject interface{}) error {
+	return rancherClient.doCreate(schemaType, createObj, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) doCreate(schemaType string, createObj interface{}, respObject interface{}) error {
+	if createObj == nil {
+		createObj = map[string]string{}
+	}
+	if respObject == nil {
+		respObject = &map[string]interface{}{}
+	}
+	schema, ok := rancherClient.Types[schemaType]
+	if !ok {
+		return errors.New("Unknown schema type [" + schemaType + "]")
+	}
+
+	if !contains(schema.CollectionMethods, "POST") {
+		return errors.New("Resource type [" + schemaType + "] is not creatable")
+	}
+
+	var collectionUrl string
+	collectionUrl, ok = schema.Links[COLLECTION]
+	if !ok {
+		// return errors.New("Failed to find collection URL for [" + schemaType + "]")
+		// This is a hack to address https://github.com/rancher/cattle/issues/254
+		re := regexp.MustCompile("schemas.*")
+		collectionUrl = re.ReplaceAllString(schema.Links[SELF], schema.PluralName)
+	}
+
+	return rancherClient.doModify("POST", collectionUrl, createObj, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) Update(schemaType string, existing *Resource, updates interface{}, respObject interface{}) error {
+	return rancherClient.doUpdate(schemaType, existing, updates, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) doUpdate(schemaType string, existing *Resource, updates interface{}, respObject interface{}) error {
+	if existing == nil {
+		return errors.New("Existing object is nil")
+	}
+
+	selfUrl, ok := existing.Links[SELF]
+	if !ok {
+		return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
+	}
+
+	if updates == nil {
+		updates = map[string]string{}
+	}
+
+	if respObject == nil {
+		respObject = &map[string]interface{}{}
+	}
+
+	schema, ok := rancherClient.Types[schemaType]
+	if !ok {
+		return errors.New("Unknown schema type [" + schemaType + "]")
+	}
+
+	if !contains(schema.ResourceMethods, "PUT") {
+		return errors.New("Resource type [" + schemaType + "] is not updatable")
+	}
+
+	return rancherClient.doModify("PUT", selfUrl, updates, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) ById(schemaType string, id string, respObject interface{}) error {
+	return rancherClient.doById(schemaType, id, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) doById(schemaType string, id string, respObject interface{}) error {
+	schema, ok := rancherClient.Types[schemaType]
+	if !ok {
+		return errors.New("Unknown schema type [" + schemaType + "]")
+	}
+
+	if !contains(schema.ResourceMethods, "GET") {
+		return errors.New("Resource type [" + schemaType + "] can not be looked up by ID")
+	}
+
+	collectionUrl, ok := schema.Links[COLLECTION]
+	if !ok {
+		return errors.New("Failed to find collection URL for [" + schemaType + "]")
+	}
+
+	err := rancherClient.doGet(collectionUrl+"/"+id, nil, respObject)
+	//TODO check for 404 and return nil, nil
+	return err
+}
+
+func (rancherClient *RancherBaseClientImpl) Delete(existing *Resource) error {
+	if existing == nil {
+		return nil
+	}
+	return rancherClient.doResourceDelete(existing.Type, existing)
+}
+
+func (rancherClient *RancherBaseClientImpl) doResourceDelete(schemaType string, existing *Resource) error {
+	schema, ok := rancherClient.Types[schemaType]
+	if !ok {
+		return errors.New("Unknown schema type [" + schemaType + "]")
+	}
+
+	if !contains(schema.ResourceMethods, "DELETE") {
+		return errors.New("Resource type [" + schemaType + "] can not be deleted")
+	}
+
+	selfUrl, ok := existing.Links[SELF]
+	if !ok {
+		return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
+	}
+
+	return rancherClient.doDelete(selfUrl)
+}
+
+func (rancherClient *RancherBaseClientImpl) Reload(existing *Resource, output interface{}) error {
+	selfUrl, ok := existing.Links[SELF]
+	if !ok {
+		return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
+	}
+
+	return rancherClient.doGet(selfUrl, NewListOpts(), output)
+}
+
+func (rancherClient *RancherBaseClientImpl) Action(schemaType string, action string,
+	existing *Resource, inputObject, respObject interface{}) error {
+	return rancherClient.doAction(schemaType, action, existing, inputObject, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) doAction(schemaType string, action string,
+	existing *Resource, inputObject, respObject interface{}) error {
+
+	if existing == nil {
+		return errors.New("Existing object is nil")
+	}
+
+	actionUrl, ok := existing.Actions[action]
+	if !ok {
+		return errors.New(fmt.Sprintf("Action [%v] not available on [%v]", action, existing))
+	}
+
+	_, ok = rancherClient.Types[schemaType]
+	if !ok {
+		return errors.New("Unknown schema type [" + schemaType + "]")
+	}
+
+	var input io.Reader
+
+	if inputObject != nil {
+		bodyContent, err := json.Marshal(inputObject)
+		if err != nil {
+			return err
+		}
+		if debug {
+			fmt.Println("Request => " + string(bodyContent))
+		}
+		input = bytes.NewBuffer(bodyContent)
+	}
+
+	client := rancherClient.newHttpClient()
+	req, err := http.NewRequest("POST", actionUrl, input)
+	if err != nil {
+		return err
+	}
+
+	rancherClient.setupRequest(req)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Content-Length", "0")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 300 {
+		return newApiError(resp, actionUrl)
+	}
+
+	byteContent, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if debug {
+		fmt.Println("Response <= " + string(byteContent))
+	}
+
+	return json.Unmarshal(byteContent, respObject)
+}
+
+func (rancherClient *RancherBaseClientImpl) GetOpts() *ClientOpts {
+	return rancherClient.Opts
+}
+
+func (rancherClient *RancherBaseClientImpl) GetSchemas() *Schemas {
+	return rancherClient.Schemas
+}
+
+func (rancherClient *RancherBaseClientImpl) GetTypes() map[string]Schema {
+	return rancherClient.Types
+}
+
+func init() {
+	debug = os.Getenv("RANCHER_CLIENT_DEBUG") == "true"
+	if debug {
+		fmt.Println("Rancher client debug on")
+	}
+}

vendor/github.com/rancher/go-rancher/v2/generated_account.go

@@ -0,0 +1,186 @@
+package client
+
+const (
+	ACCOUNT_TYPE = "account"
+)
+
+type Account struct {
+	Resource
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	ExternalIdType string `json:"externalIdType,omitempty" yaml:"external_id_type,omitempty"`
+
+	Identity string `json:"identity,omitempty" yaml:"identity,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Version string `json:"version,omitempty" yaml:"version,omitempty"`
+}
+
+type AccountCollection struct {
+	Collection
+	Data   []Account `json:"data,omitempty"`
+	client *AccountClient
+}
+
+type AccountClient struct {
+	rancherClient *RancherClient
+}
+
+type AccountOperations interface {
+	List(opts *ListOpts) (*AccountCollection, error)
+	Create(opts *Account) (*Account, error)
+	Update(existing *Account, updates interface{}) (*Account, error)
+	ById(id string) (*Account, error)
+	Delete(container *Account) error
+
+	ActionActivate(*Account) (*Account, error)
+
+	ActionCreate(*Account) (*Account, error)
+
+	ActionDeactivate(*Account) (*Account, error)
+
+	ActionPurge(*Account) (*Account, error)
+
+	ActionRemove(*Account) (*Account, error)
+
+	ActionUpdate(*Account) (*Account, error)
+
+	ActionUpgrade(*Account) (*Account, error)
+}
+
+func newAccountClient(rancherClient *RancherClient) *AccountClient {
+	return &AccountClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *AccountClient) Create(container *Account) (*Account, error) {
+	resp := &Account{}
+	err := c.rancherClient.doCreate(ACCOUNT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *AccountClient) Update(existing *Account, updates interface{}) (*Account, error) {
+	resp := &Account{}
+	err := c.rancherClient.doUpdate(ACCOUNT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *AccountClient) List(opts *ListOpts) (*AccountCollection, error) {
+	resp := &AccountCollection{}
+	err := c.rancherClient.doList(ACCOUNT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *AccountCollection) Next() (*AccountCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &AccountCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *AccountClient) ById(id string) (*Account, error) {
+	resp := &Account{}
+	err := c.rancherClient.doById(ACCOUNT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *AccountClient) Delete(container *Account) error {
+	return c.rancherClient.doResourceDelete(ACCOUNT_TYPE, &container.Resource)
+}
+
+func (c *AccountClient) ActionActivate(resource *Account) (*Account, error) {
+
+	resp := &Account{}
+
+	err := c.rancherClient.doAction(ACCOUNT_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AccountClient) ActionCreate(resource *Account) (*Account, error) {
+
+	resp := &Account{}
+
+	err := c.rancherClient.doAction(ACCOUNT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AccountClient) ActionDeactivate(resource *Account) (*Account, error) {
+
+	resp := &Account{}
+
+	err := c.rancherClient.doAction(ACCOUNT_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AccountClient) ActionPurge(resource *Account) (*Account, error) {
+
+	resp := &Account{}
+
+	err := c.rancherClient.doAction(ACCOUNT_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AccountClient) ActionRemove(resource *Account) (*Account, error) {
+
+	resp := &Account{}
+
+	err := c.rancherClient.doAction(ACCOUNT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AccountClient) ActionUpdate(resource *Account) (*Account, error) {
+
+	resp := &Account{}
+
+	err := c.rancherClient.doAction(ACCOUNT_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AccountClient) ActionUpgrade(resource *Account) (*Account, error) {
+
+	resp := &Account{}
+
+	err := c.rancherClient.doAction(ACCOUNT_TYPE, "upgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_active_setting.go

@@ -0,0 +1,87 @@
+package client
+
+const (
+	ACTIVE_SETTING_TYPE = "activeSetting"
+)
+
+type ActiveSetting struct {
+	Resource
+
+	ActiveValue interface{} `json:"activeValue,omitempty" yaml:"active_value,omitempty"`
+
+	InDb bool `json:"inDb,omitempty" yaml:"in_db,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Source string `json:"source,omitempty" yaml:"source,omitempty"`
+
+	Value string `json:"value,omitempty" yaml:"value,omitempty"`
+}
+
+type ActiveSettingCollection struct {
+	Collection
+	Data   []ActiveSetting `json:"data,omitempty"`
+	client *ActiveSettingClient
+}
+
+type ActiveSettingClient struct {
+	rancherClient *RancherClient
+}
+
+type ActiveSettingOperations interface {
+	List(opts *ListOpts) (*ActiveSettingCollection, error)
+	Create(opts *ActiveSetting) (*ActiveSetting, error)
+	Update(existing *ActiveSetting, updates interface{}) (*ActiveSetting, error)
+	ById(id string) (*ActiveSetting, error)
+	Delete(container *ActiveSetting) error
+}
+
+func newActiveSettingClient(rancherClient *RancherClient) *ActiveSettingClient {
+	return &ActiveSettingClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ActiveSettingClient) Create(container *ActiveSetting) (*ActiveSetting, error) {
+	resp := &ActiveSetting{}
+	err := c.rancherClient.doCreate(ACTIVE_SETTING_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ActiveSettingClient) Update(existing *ActiveSetting, updates interface{}) (*ActiveSetting, error) {
+	resp := &ActiveSetting{}
+	err := c.rancherClient.doUpdate(ACTIVE_SETTING_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ActiveSettingClient) List(opts *ListOpts) (*ActiveSettingCollection, error) {
+	resp := &ActiveSettingCollection{}
+	err := c.rancherClient.doList(ACTIVE_SETTING_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ActiveSettingCollection) Next() (*ActiveSettingCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ActiveSettingCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ActiveSettingClient) ById(id string) (*ActiveSetting, error) {
+	resp := &ActiveSetting{}
+	err := c.rancherClient.doById(ACTIVE_SETTING_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ActiveSettingClient) Delete(container *ActiveSetting) error {
+	return c.rancherClient.doResourceDelete(ACTIVE_SETTING_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_add_outputs_input.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	ADD_OUTPUTS_INPUT_TYPE = "addOutputsInput"
+)
+
+type AddOutputsInput struct {
+	Resource
+
+	Outputs map[string]interface{} `json:"outputs,omitempty" yaml:"outputs,omitempty"`
+}
+
+type AddOutputsInputCollection struct {
+	Collection
+	Data   []AddOutputsInput `json:"data,omitempty"`
+	client *AddOutputsInputClient
+}
+
+type AddOutputsInputClient struct {
+	rancherClient *RancherClient
+}
+
+type AddOutputsInputOperations interface {
+	List(opts *ListOpts) (*AddOutputsInputCollection, error)
+	Create(opts *AddOutputsInput) (*AddOutputsInput, error)
+	Update(existing *AddOutputsInput, updates interface{}) (*AddOutputsInput, error)
+	ById(id string) (*AddOutputsInput, error)
+	Delete(container *AddOutputsInput) error
+}
+
+func newAddOutputsInputClient(rancherClient *RancherClient) *AddOutputsInputClient {
+	return &AddOutputsInputClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *AddOutputsInputClient) Create(container *AddOutputsInput) (*AddOutputsInput, error) {
+	resp := &AddOutputsInput{}
+	err := c.rancherClient.doCreate(ADD_OUTPUTS_INPUT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *AddOutputsInputClient) Update(existing *AddOutputsInput, updates interface{}) (*AddOutputsInput, error) {
+	resp := &AddOutputsInput{}
+	err := c.rancherClient.doUpdate(ADD_OUTPUTS_INPUT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *AddOutputsInputClient) List(opts *ListOpts) (*AddOutputsInputCollection, error) {
+	resp := &AddOutputsInputCollection{}
+	err := c.rancherClient.doList(ADD_OUTPUTS_INPUT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *AddOutputsInputCollection) Next() (*AddOutputsInputCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &AddOutputsInputCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *AddOutputsInputClient) ById(id string) (*AddOutputsInput, error) {
+	resp := &AddOutputsInput{}
+	err := c.rancherClient.doById(ADD_OUTPUTS_INPUT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *AddOutputsInputClient) Delete(container *AddOutputsInput) error {
+	return c.rancherClient.doResourceDelete(ADD_OUTPUTS_INPUT_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_add_remove_service_link_input.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	ADD_REMOVE_SERVICE_LINK_INPUT_TYPE = "addRemoveServiceLinkInput"
+)
+
+type AddRemoveServiceLinkInput struct {
+	Resource
+
+	ServiceLink ServiceLink `json:"serviceLink,omitempty" yaml:"service_link,omitempty"`
+}
+
+type AddRemoveServiceLinkInputCollection struct {
+	Collection
+	Data   []AddRemoveServiceLinkInput `json:"data,omitempty"`
+	client *AddRemoveServiceLinkInputClient
+}
+
+type AddRemoveServiceLinkInputClient struct {
+	rancherClient *RancherClient
+}
+
+type AddRemoveServiceLinkInputOperations interface {
+	List(opts *ListOpts) (*AddRemoveServiceLinkInputCollection, error)
+	Create(opts *AddRemoveServiceLinkInput) (*AddRemoveServiceLinkInput, error)
+	Update(existing *AddRemoveServiceLinkInput, updates interface{}) (*AddRemoveServiceLinkInput, error)
+	ById(id string) (*AddRemoveServiceLinkInput, error)
+	Delete(container *AddRemoveServiceLinkInput) error
+}
+
+func newAddRemoveServiceLinkInputClient(rancherClient *RancherClient) *AddRemoveServiceLinkInputClient {
+	return &AddRemoveServiceLinkInputClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *AddRemoveServiceLinkInputClient) Create(container *AddRemoveServiceLinkInput) (*AddRemoveServiceLinkInput, error) {
+	resp := &AddRemoveServiceLinkInput{}
+	err := c.rancherClient.doCreate(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *AddRemoveServiceLinkInputClient) Update(existing *AddRemoveServiceLinkInput, updates interface{}) (*AddRemoveServiceLinkInput, error) {
+	resp := &AddRemoveServiceLinkInput{}
+	err := c.rancherClient.doUpdate(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *AddRemoveServiceLinkInputClient) List(opts *ListOpts) (*AddRemoveServiceLinkInputCollection, error) {
+	resp := &AddRemoveServiceLinkInputCollection{}
+	err := c.rancherClient.doList(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *AddRemoveServiceLinkInputCollection) Next() (*AddRemoveServiceLinkInputCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &AddRemoveServiceLinkInputCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *AddRemoveServiceLinkInputClient) ById(id string) (*AddRemoveServiceLinkInput, error) {
+	resp := &AddRemoveServiceLinkInput{}
+	err := c.rancherClient.doById(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *AddRemoveServiceLinkInputClient) Delete(container *AddRemoveServiceLinkInput) error {
+	return c.rancherClient.doResourceDelete(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_agent.go

@@ -0,0 +1,206 @@
+package client
+
+const (
+	AGENT_TYPE = "agent"
+)
+
+type Agent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ManagedConfig bool `json:"managedConfig,omitempty" yaml:"managed_config,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uri string `json:"uri,omitempty" yaml:"uri,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type AgentCollection struct {
+	Collection
+	Data   []Agent `json:"data,omitempty"`
+	client *AgentClient
+}
+
+type AgentClient struct {
+	rancherClient *RancherClient
+}
+
+type AgentOperations interface {
+	List(opts *ListOpts) (*AgentCollection, error)
+	Create(opts *Agent) (*Agent, error)
+	Update(existing *Agent, updates interface{}) (*Agent, error)
+	ById(id string) (*Agent, error)
+	Delete(container *Agent) error
+
+	ActionActivate(*Agent) (*Agent, error)
+
+	ActionCreate(*Agent) (*Agent, error)
+
+	ActionDeactivate(*Agent) (*Agent, error)
+
+	ActionDisconnect(*Agent) (*Agent, error)
+
+	ActionFinishreconnect(*Agent) (*Agent, error)
+
+	ActionPurge(*Agent) (*Agent, error)
+
+	ActionReconnect(*Agent) (*Agent, error)
+
+	ActionRemove(*Agent) (*Agent, error)
+
+	ActionUpdate(*Agent) (*Agent, error)
+}
+
+func newAgentClient(rancherClient *RancherClient) *AgentClient {
+	return &AgentClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *AgentClient) Create(container *Agent) (*Agent, error) {
+	resp := &Agent{}
+	err := c.rancherClient.doCreate(AGENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *AgentClient) Update(existing *Agent, updates interface{}) (*Agent, error) {
+	resp := &Agent{}
+	err := c.rancherClient.doUpdate(AGENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *AgentClient) List(opts *ListOpts) (*AgentCollection, error) {
+	resp := &AgentCollection{}
+	err := c.rancherClient.doList(AGENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *AgentCollection) Next() (*AgentCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &AgentCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *AgentClient) ById(id string) (*Agent, error) {
+	resp := &Agent{}
+	err := c.rancherClient.doById(AGENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *AgentClient) Delete(container *Agent) error {
+	return c.rancherClient.doResourceDelete(AGENT_TYPE, &container.Resource)
+}
+
+func (c *AgentClient) ActionActivate(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionCreate(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionDeactivate(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionDisconnect(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "disconnect", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionFinishreconnect(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "finishreconnect", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionPurge(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionReconnect(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "reconnect", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionRemove(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *AgentClient) ActionUpdate(resource *Agent) (*Agent, error) {
+
+	resp := &Agent{}
+
+	err := c.rancherClient.doAction(AGENT_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_amazonec2config.go

@@ -0,0 +1,137 @@
+package client
+
+const (
+	AMAZONEC2CONFIG_TYPE = "amazonec2Config"
+)
+
+type Amazonec2Config struct {
+	Resource
+
+	AccessKey string `json:"accessKey,omitempty" yaml:"access_key,omitempty"`
+
+	Ami string `json:"ami,omitempty" yaml:"ami,omitempty"`
+
+	BlockDurationMinutes string `json:"blockDurationMinutes,omitempty" yaml:"block_duration_minutes,omitempty"`
+
+	DeviceName string `json:"deviceName,omitempty" yaml:"device_name,omitempty"`
+
+	Endpoint string `json:"endpoint,omitempty" yaml:"endpoint,omitempty"`
+
+	IamInstanceProfile string `json:"iamInstanceProfile,omitempty" yaml:"iam_instance_profile,omitempty"`
+
+	InsecureTransport bool `json:"insecureTransport,omitempty" yaml:"insecure_transport,omitempty"`
+
+	InstanceType string `json:"instanceType,omitempty" yaml:"instance_type,omitempty"`
+
+	KeypairName string `json:"keypairName,omitempty" yaml:"keypair_name,omitempty"`
+
+	Monitoring bool `json:"monitoring,omitempty" yaml:"monitoring,omitempty"`
+
+	OpenPort []string `json:"openPort,omitempty" yaml:"open_port,omitempty"`
+
+	PrivateAddressOnly bool `json:"privateAddressOnly,omitempty" yaml:"private_address_only,omitempty"`
+
+	Region string `json:"region,omitempty" yaml:"region,omitempty"`
+
+	RequestSpotInstance bool `json:"requestSpotInstance,omitempty" yaml:"request_spot_instance,omitempty"`
+
+	Retries string `json:"retries,omitempty" yaml:"retries,omitempty"`
+
+	RootSize string `json:"rootSize,omitempty" yaml:"root_size,omitempty"`
+
+	SecretKey string `json:"secretKey,omitempty" yaml:"secret_key,omitempty"`
+
+	SecurityGroup []string `json:"securityGroup,omitempty" yaml:"security_group,omitempty"`
+
+	SessionToken string `json:"sessionToken,omitempty" yaml:"session_token,omitempty"`
+
+	SpotPrice string `json:"spotPrice,omitempty" yaml:"spot_price,omitempty"`
+
+	SshKeypath string `json:"sshKeypath,omitempty" yaml:"ssh_keypath,omitempty"`
+
+	SshUser string `json:"sshUser,omitempty" yaml:"ssh_user,omitempty"`
+
+	SubnetId string `json:"subnetId,omitempty" yaml:"subnet_id,omitempty"`
+
+	Tags string `json:"tags,omitempty" yaml:"tags,omitempty"`
+
+	UseEbsOptimizedInstance bool `json:"useEbsOptimizedInstance,omitempty" yaml:"use_ebs_optimized_instance,omitempty"`
+
+	UsePrivateAddress bool `json:"usePrivateAddress,omitempty" yaml:"use_private_address,omitempty"`
+
+	Userdata string `json:"userdata,omitempty" yaml:"userdata,omitempty"`
+
+	VolumeType string `json:"volumeType,omitempty" yaml:"volume_type,omitempty"`
+
+	VpcId string `json:"vpcId,omitempty" yaml:"vpc_id,omitempty"`
+
+	Zone string `json:"zone,omitempty" yaml:"zone,omitempty"`
+}
+
+type Amazonec2ConfigCollection struct {
+	Collection
+	Data   []Amazonec2Config `json:"data,omitempty"`
+	client *Amazonec2ConfigClient
+}
+
+type Amazonec2ConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type Amazonec2ConfigOperations interface {
+	List(opts *ListOpts) (*Amazonec2ConfigCollection, error)
+	Create(opts *Amazonec2Config) (*Amazonec2Config, error)
+	Update(existing *Amazonec2Config, updates interface{}) (*Amazonec2Config, error)
+	ById(id string) (*Amazonec2Config, error)
+	Delete(container *Amazonec2Config) error
+}
+
+func newAmazonec2ConfigClient(rancherClient *RancherClient) *Amazonec2ConfigClient {
+	return &Amazonec2ConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *Amazonec2ConfigClient) Create(container *Amazonec2Config) (*Amazonec2Config, error) {
+	resp := &Amazonec2Config{}
+	err := c.rancherClient.doCreate(AMAZONEC2CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *Amazonec2ConfigClient) Update(existing *Amazonec2Config, updates interface{}) (*Amazonec2Config, error) {
+	resp := &Amazonec2Config{}
+	err := c.rancherClient.doUpdate(AMAZONEC2CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *Amazonec2ConfigClient) List(opts *ListOpts) (*Amazonec2ConfigCollection, error) {
+	resp := &Amazonec2ConfigCollection{}
+	err := c.rancherClient.doList(AMAZONEC2CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *Amazonec2ConfigCollection) Next() (*Amazonec2ConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &Amazonec2ConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *Amazonec2ConfigClient) ById(id string) (*Amazonec2Config, error) {
+	resp := &Amazonec2Config{}
+	err := c.rancherClient.doById(AMAZONEC2CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *Amazonec2ConfigClient) Delete(container *Amazonec2Config) error {
+	return c.rancherClient.doResourceDelete(AMAZONEC2CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_api_key.go

@@ -0,0 +1,173 @@
+package client
+
+const (
+	API_KEY_TYPE = "apiKey"
+)
+
+type ApiKey struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PublicValue string `json:"publicValue,omitempty" yaml:"public_value,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	SecretValue string `json:"secretValue,omitempty" yaml:"secret_value,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ApiKeyCollection struct {
+	Collection
+	Data   []ApiKey `json:"data,omitempty"`
+	client *ApiKeyClient
+}
+
+type ApiKeyClient struct {
+	rancherClient *RancherClient
+}
+
+type ApiKeyOperations interface {
+	List(opts *ListOpts) (*ApiKeyCollection, error)
+	Create(opts *ApiKey) (*ApiKey, error)
+	Update(existing *ApiKey, updates interface{}) (*ApiKey, error)
+	ById(id string) (*ApiKey, error)
+	Delete(container *ApiKey) error
+
+	ActionActivate(*ApiKey) (*Credential, error)
+
+	ActionCreate(*ApiKey) (*Credential, error)
+
+	ActionDeactivate(*ApiKey) (*Credential, error)
+
+	ActionPurge(*ApiKey) (*Credential, error)
+
+	ActionRemove(*ApiKey) (*Credential, error)
+
+	ActionUpdate(*ApiKey) (*Credential, error)
+}
+
+func newApiKeyClient(rancherClient *RancherClient) *ApiKeyClient {
+	return &ApiKeyClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ApiKeyClient) Create(container *ApiKey) (*ApiKey, error) {
+	resp := &ApiKey{}
+	err := c.rancherClient.doCreate(API_KEY_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ApiKeyClient) Update(existing *ApiKey, updates interface{}) (*ApiKey, error) {
+	resp := &ApiKey{}
+	err := c.rancherClient.doUpdate(API_KEY_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ApiKeyClient) List(opts *ListOpts) (*ApiKeyCollection, error) {
+	resp := &ApiKeyCollection{}
+	err := c.rancherClient.doList(API_KEY_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ApiKeyCollection) Next() (*ApiKeyCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ApiKeyCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ApiKeyClient) ById(id string) (*ApiKey, error) {
+	resp := &ApiKey{}
+	err := c.rancherClient.doById(API_KEY_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ApiKeyClient) Delete(container *ApiKey) error {
+	return c.rancherClient.doResourceDelete(API_KEY_TYPE, &container.Resource)
+}
+
+func (c *ApiKeyClient) ActionActivate(resource *ApiKey) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(API_KEY_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ApiKeyClient) ActionCreate(resource *ApiKey) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(API_KEY_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ApiKeyClient) ActionDeactivate(resource *ApiKey) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(API_KEY_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ApiKeyClient) ActionPurge(resource *ApiKey) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(API_KEY_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ApiKeyClient) ActionRemove(resource *ApiKey) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(API_KEY_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ApiKeyClient) ActionUpdate(resource *ApiKey) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(API_KEY_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_audit_log.go

@@ -0,0 +1,105 @@
+package client
+
+const (
+	AUDIT_LOG_TYPE = "auditLog"
+)
+
+type AuditLog struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AuthType string `json:"authType,omitempty" yaml:"auth_type,omitempty"`
+
+	AuthenticatedAsAccountId string `json:"authenticatedAsAccountId,omitempty" yaml:"authenticated_as_account_id,omitempty"`
+
+	AuthenticatedAsIdentityId string `json:"authenticatedAsIdentityId,omitempty" yaml:"authenticated_as_identity_id,omitempty"`
+
+	ClientIp string `json:"clientIp,omitempty" yaml:"client_ip,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	RequestObject string `json:"requestObject,omitempty" yaml:"request_object,omitempty"`
+
+	ResourceId int64 `json:"resourceId,omitempty" yaml:"resource_id,omitempty"`
+
+	ResourceType string `json:"resourceType,omitempty" yaml:"resource_type,omitempty"`
+
+	ResponseCode string `json:"responseCode,omitempty" yaml:"response_code,omitempty"`
+
+	ResponseObject string `json:"responseObject,omitempty" yaml:"response_object,omitempty"`
+}
+
+type AuditLogCollection struct {
+	Collection
+	Data   []AuditLog `json:"data,omitempty"`
+	client *AuditLogClient
+}
+
+type AuditLogClient struct {
+	rancherClient *RancherClient
+}
+
+type AuditLogOperations interface {
+	List(opts *ListOpts) (*AuditLogCollection, error)
+	Create(opts *AuditLog) (*AuditLog, error)
+	Update(existing *AuditLog, updates interface{}) (*AuditLog, error)
+	ById(id string) (*AuditLog, error)
+	Delete(container *AuditLog) error
+}
+
+func newAuditLogClient(rancherClient *RancherClient) *AuditLogClient {
+	return &AuditLogClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *AuditLogClient) Create(container *AuditLog) (*AuditLog, error) {
+	resp := &AuditLog{}
+	err := c.rancherClient.doCreate(AUDIT_LOG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *AuditLogClient) Update(existing *AuditLog, updates interface{}) (*AuditLog, error) {
+	resp := &AuditLog{}
+	err := c.rancherClient.doUpdate(AUDIT_LOG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *AuditLogClient) List(opts *ListOpts) (*AuditLogCollection, error) {
+	resp := &AuditLogCollection{}
+	err := c.rancherClient.doList(AUDIT_LOG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *AuditLogCollection) Next() (*AuditLogCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &AuditLogCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *AuditLogClient) ById(id string) (*AuditLog, error) {
+	resp := &AuditLog{}
+	err := c.rancherClient.doById(AUDIT_LOG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *AuditLogClient) Delete(container *AuditLog) error {
+	return c.rancherClient.doResourceDelete(AUDIT_LOG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_azure_config.go

@@ -0,0 +1,121 @@
+package client
+
+const (
+	AZURE_CONFIG_TYPE = "azureConfig"
+)
+
+type AzureConfig struct {
+	Resource
+
+	AvailabilitySet string `json:"availabilitySet,omitempty" yaml:"availability_set,omitempty"`
+
+	ClientId string `json:"clientId,omitempty" yaml:"client_id,omitempty"`
+
+	ClientSecret string `json:"clientSecret,omitempty" yaml:"client_secret,omitempty"`
+
+	CustomData string `json:"customData,omitempty" yaml:"custom_data,omitempty"`
+
+	Dns string `json:"dns,omitempty" yaml:"dns,omitempty"`
+
+	DockerPort string `json:"dockerPort,omitempty" yaml:"docker_port,omitempty"`
+
+	Environment string `json:"environment,omitempty" yaml:"environment,omitempty"`
+
+	Image string `json:"image,omitempty" yaml:"image,omitempty"`
+
+	Location string `json:"location,omitempty" yaml:"location,omitempty"`
+
+	NoPublicIp bool `json:"noPublicIp,omitempty" yaml:"no_public_ip,omitempty"`
+
+	OpenPort []string `json:"openPort,omitempty" yaml:"open_port,omitempty"`
+
+	PrivateIpAddress string `json:"privateIpAddress,omitempty" yaml:"private_ip_address,omitempty"`
+
+	ResourceGroup string `json:"resourceGroup,omitempty" yaml:"resource_group,omitempty"`
+
+	Size string `json:"size,omitempty" yaml:"size,omitempty"`
+
+	SshUser string `json:"sshUser,omitempty" yaml:"ssh_user,omitempty"`
+
+	StaticPublicIp bool `json:"staticPublicIp,omitempty" yaml:"static_public_ip,omitempty"`
+
+	StorageType string `json:"storageType,omitempty" yaml:"storage_type,omitempty"`
+
+	Subnet string `json:"subnet,omitempty" yaml:"subnet,omitempty"`
+
+	SubnetPrefix string `json:"subnetPrefix,omitempty" yaml:"subnet_prefix,omitempty"`
+
+	SubscriptionId string `json:"subscriptionId,omitempty" yaml:"subscription_id,omitempty"`
+
+	UsePrivateIp bool `json:"usePrivateIp,omitempty" yaml:"use_private_ip,omitempty"`
+
+	Vnet string `json:"vnet,omitempty" yaml:"vnet,omitempty"`
+}
+
+type AzureConfigCollection struct {
+	Collection
+	Data   []AzureConfig `json:"data,omitempty"`
+	client *AzureConfigClient
+}
+
+type AzureConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type AzureConfigOperations interface {
+	List(opts *ListOpts) (*AzureConfigCollection, error)
+	Create(opts *AzureConfig) (*AzureConfig, error)
+	Update(existing *AzureConfig, updates interface{}) (*AzureConfig, error)
+	ById(id string) (*AzureConfig, error)
+	Delete(container *AzureConfig) error
+}
+
+func newAzureConfigClient(rancherClient *RancherClient) *AzureConfigClient {
+	return &AzureConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *AzureConfigClient) Create(container *AzureConfig) (*AzureConfig, error) {
+	resp := &AzureConfig{}
+	err := c.rancherClient.doCreate(AZURE_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *AzureConfigClient) Update(existing *AzureConfig, updates interface{}) (*AzureConfig, error) {
+	resp := &AzureConfig{}
+	err := c.rancherClient.doUpdate(AZURE_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *AzureConfigClient) List(opts *ListOpts) (*AzureConfigCollection, error) {
+	resp := &AzureConfigCollection{}
+	err := c.rancherClient.doList(AZURE_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *AzureConfigCollection) Next() (*AzureConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &AzureConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *AzureConfigClient) ById(id string) (*AzureConfig, error) {
+	resp := &AzureConfig{}
+	err := c.rancherClient.doById(AZURE_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *AzureConfigClient) Delete(container *AzureConfig) error {
+	return c.rancherClient.doResourceDelete(AZURE_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_azureadconfig.go

@@ -0,0 +1,93 @@
+package client
+
+const (
+	AZUREADCONFIG_TYPE = "azureadconfig"
+)
+
+type Azureadconfig struct {
+	Resource
+
+	AccessMode string `json:"accessMode,omitempty" yaml:"access_mode,omitempty"`
+
+	AdminAccountPassword string `json:"adminAccountPassword,omitempty" yaml:"admin_account_password,omitempty"`
+
+	AdminAccountUsername string `json:"adminAccountUsername,omitempty" yaml:"admin_account_username,omitempty"`
+
+	ClientId string `json:"clientId,omitempty" yaml:"client_id,omitempty"`
+
+	Domain string `json:"domain,omitempty" yaml:"domain,omitempty"`
+
+	Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	TenantId string `json:"tenantId,omitempty" yaml:"tenant_id,omitempty"`
+}
+
+type AzureadconfigCollection struct {
+	Collection
+	Data   []Azureadconfig `json:"data,omitempty"`
+	client *AzureadconfigClient
+}
+
+type AzureadconfigClient struct {
+	rancherClient *RancherClient
+}
+
+type AzureadconfigOperations interface {
+	List(opts *ListOpts) (*AzureadconfigCollection, error)
+	Create(opts *Azureadconfig) (*Azureadconfig, error)
+	Update(existing *Azureadconfig, updates interface{}) (*Azureadconfig, error)
+	ById(id string) (*Azureadconfig, error)
+	Delete(container *Azureadconfig) error
+}
+
+func newAzureadconfigClient(rancherClient *RancherClient) *AzureadconfigClient {
+	return &AzureadconfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *AzureadconfigClient) Create(container *Azureadconfig) (*Azureadconfig, error) {
+	resp := &Azureadconfig{}
+	err := c.rancherClient.doCreate(AZUREADCONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *AzureadconfigClient) Update(existing *Azureadconfig, updates interface{}) (*Azureadconfig, error) {
+	resp := &Azureadconfig{}
+	err := c.rancherClient.doUpdate(AZUREADCONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *AzureadconfigClient) List(opts *ListOpts) (*AzureadconfigCollection, error) {
+	resp := &AzureadconfigCollection{}
+	err := c.rancherClient.doList(AZUREADCONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *AzureadconfigCollection) Next() (*AzureadconfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &AzureadconfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *AzureadconfigClient) ById(id string) (*Azureadconfig, error) {
+	resp := &Azureadconfig{}
+	err := c.rancherClient.doById(AZUREADCONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *AzureadconfigClient) Delete(container *Azureadconfig) error {
+	return c.rancherClient.doResourceDelete(AZUREADCONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_backup.go

@@ -0,0 +1,133 @@
+package client
+
+const (
+	BACKUP_TYPE = "backup"
+)
+
+type Backup struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	BackupTargetId string `json:"backupTargetId,omitempty" yaml:"backup_target_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	SnapshotId string `json:"snapshotId,omitempty" yaml:"snapshot_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uri string `json:"uri,omitempty" yaml:"uri,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	VolumeId string `json:"volumeId,omitempty" yaml:"volume_id,omitempty"`
+}
+
+type BackupCollection struct {
+	Collection
+	Data   []Backup `json:"data,omitempty"`
+	client *BackupClient
+}
+
+type BackupClient struct {
+	rancherClient *RancherClient
+}
+
+type BackupOperations interface {
+	List(opts *ListOpts) (*BackupCollection, error)
+	Create(opts *Backup) (*Backup, error)
+	Update(existing *Backup, updates interface{}) (*Backup, error)
+	ById(id string) (*Backup, error)
+	Delete(container *Backup) error
+
+	ActionCreate(*Backup) (*Backup, error)
+
+	ActionRemove(*Backup) (*Backup, error)
+}
+
+func newBackupClient(rancherClient *RancherClient) *BackupClient {
+	return &BackupClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *BackupClient) Create(container *Backup) (*Backup, error) {
+	resp := &Backup{}
+	err := c.rancherClient.doCreate(BACKUP_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *BackupClient) Update(existing *Backup, updates interface{}) (*Backup, error) {
+	resp := &Backup{}
+	err := c.rancherClient.doUpdate(BACKUP_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *BackupClient) List(opts *ListOpts) (*BackupCollection, error) {
+	resp := &BackupCollection{}
+	err := c.rancherClient.doList(BACKUP_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *BackupCollection) Next() (*BackupCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &BackupCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *BackupClient) ById(id string) (*Backup, error) {
+	resp := &Backup{}
+	err := c.rancherClient.doById(BACKUP_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *BackupClient) Delete(container *Backup) error {
+	return c.rancherClient.doResourceDelete(BACKUP_TYPE, &container.Resource)
+}
+
+func (c *BackupClient) ActionCreate(resource *Backup) (*Backup, error) {
+
+	resp := &Backup{}
+
+	err := c.rancherClient.doAction(BACKUP_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *BackupClient) ActionRemove(resource *Backup) (*Backup, error) {
+
+	resp := &Backup{}
+
+	err := c.rancherClient.doAction(BACKUP_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_backup_target.go

@@ -0,0 +1,127 @@
+package client
+
+const (
+	BACKUP_TARGET_TYPE = "backupTarget"
+)
+
+type BackupTarget struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	NfsConfig *NfsConfig `json:"nfsConfig,omitempty" yaml:"nfs_config,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type BackupTargetCollection struct {
+	Collection
+	Data   []BackupTarget `json:"data,omitempty"`
+	client *BackupTargetClient
+}
+
+type BackupTargetClient struct {
+	rancherClient *RancherClient
+}
+
+type BackupTargetOperations interface {
+	List(opts *ListOpts) (*BackupTargetCollection, error)
+	Create(opts *BackupTarget) (*BackupTarget, error)
+	Update(existing *BackupTarget, updates interface{}) (*BackupTarget, error)
+	ById(id string) (*BackupTarget, error)
+	Delete(container *BackupTarget) error
+
+	ActionCreate(*BackupTarget) (*BackupTarget, error)
+
+	ActionRemove(*BackupTarget) (*BackupTarget, error)
+}
+
+func newBackupTargetClient(rancherClient *RancherClient) *BackupTargetClient {
+	return &BackupTargetClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *BackupTargetClient) Create(container *BackupTarget) (*BackupTarget, error) {
+	resp := &BackupTarget{}
+	err := c.rancherClient.doCreate(BACKUP_TARGET_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *BackupTargetClient) Update(existing *BackupTarget, updates interface{}) (*BackupTarget, error) {
+	resp := &BackupTarget{}
+	err := c.rancherClient.doUpdate(BACKUP_TARGET_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *BackupTargetClient) List(opts *ListOpts) (*BackupTargetCollection, error) {
+	resp := &BackupTargetCollection{}
+	err := c.rancherClient.doList(BACKUP_TARGET_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *BackupTargetCollection) Next() (*BackupTargetCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &BackupTargetCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *BackupTargetClient) ById(id string) (*BackupTarget, error) {
+	resp := &BackupTarget{}
+	err := c.rancherClient.doById(BACKUP_TARGET_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *BackupTargetClient) Delete(container *BackupTarget) error {
+	return c.rancherClient.doResourceDelete(BACKUP_TARGET_TYPE, &container.Resource)
+}
+
+func (c *BackupTargetClient) ActionCreate(resource *BackupTarget) (*BackupTarget, error) {
+
+	resp := &BackupTarget{}
+
+	err := c.rancherClient.doAction(BACKUP_TARGET_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *BackupTargetClient) ActionRemove(resource *BackupTarget) (*BackupTarget, error) {
+
+	resp := &BackupTarget{}
+
+	err := c.rancherClient.doAction(BACKUP_TARGET_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_base_machine_config.go

@@ -0,0 +1,77 @@
+package client
+
+const (
+	BASE_MACHINE_CONFIG_TYPE = "baseMachineConfig"
+)
+
+type BaseMachineConfig struct {
+	Resource
+}
+
+type BaseMachineConfigCollection struct {
+	Collection
+	Data   []BaseMachineConfig `json:"data,omitempty"`
+	client *BaseMachineConfigClient
+}
+
+type BaseMachineConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type BaseMachineConfigOperations interface {
+	List(opts *ListOpts) (*BaseMachineConfigCollection, error)
+	Create(opts *BaseMachineConfig) (*BaseMachineConfig, error)
+	Update(existing *BaseMachineConfig, updates interface{}) (*BaseMachineConfig, error)
+	ById(id string) (*BaseMachineConfig, error)
+	Delete(container *BaseMachineConfig) error
+}
+
+func newBaseMachineConfigClient(rancherClient *RancherClient) *BaseMachineConfigClient {
+	return &BaseMachineConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *BaseMachineConfigClient) Create(container *BaseMachineConfig) (*BaseMachineConfig, error) {
+	resp := &BaseMachineConfig{}
+	err := c.rancherClient.doCreate(BASE_MACHINE_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *BaseMachineConfigClient) Update(existing *BaseMachineConfig, updates interface{}) (*BaseMachineConfig, error) {
+	resp := &BaseMachineConfig{}
+	err := c.rancherClient.doUpdate(BASE_MACHINE_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *BaseMachineConfigClient) List(opts *ListOpts) (*BaseMachineConfigCollection, error) {
+	resp := &BaseMachineConfigCollection{}
+	err := c.rancherClient.doList(BASE_MACHINE_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *BaseMachineConfigCollection) Next() (*BaseMachineConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &BaseMachineConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *BaseMachineConfigClient) ById(id string) (*BaseMachineConfig, error) {
+	resp := &BaseMachineConfig{}
+	err := c.rancherClient.doById(BASE_MACHINE_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *BaseMachineConfigClient) Delete(container *BaseMachineConfig) error {
+	return c.rancherClient.doResourceDelete(BASE_MACHINE_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_binding.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	BINDING_TYPE = "binding"
+)
+
+type Binding struct {
+	Resource
+
+	Services map[string]interface{} `json:"services,omitempty" yaml:"services,omitempty"`
+}
+
+type BindingCollection struct {
+	Collection
+	Data   []Binding `json:"data,omitempty"`
+	client *BindingClient
+}
+
+type BindingClient struct {
+	rancherClient *RancherClient
+}
+
+type BindingOperations interface {
+	List(opts *ListOpts) (*BindingCollection, error)
+	Create(opts *Binding) (*Binding, error)
+	Update(existing *Binding, updates interface{}) (*Binding, error)
+	ById(id string) (*Binding, error)
+	Delete(container *Binding) error
+}
+
+func newBindingClient(rancherClient *RancherClient) *BindingClient {
+	return &BindingClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *BindingClient) Create(container *Binding) (*Binding, error) {
+	resp := &Binding{}
+	err := c.rancherClient.doCreate(BINDING_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *BindingClient) Update(existing *Binding, updates interface{}) (*Binding, error) {
+	resp := &Binding{}
+	err := c.rancherClient.doUpdate(BINDING_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *BindingClient) List(opts *ListOpts) (*BindingCollection, error) {
+	resp := &BindingCollection{}
+	err := c.rancherClient.doList(BINDING_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *BindingCollection) Next() (*BindingCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &BindingCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *BindingClient) ById(id string) (*Binding, error) {
+	resp := &Binding{}
+	err := c.rancherClient.doById(BINDING_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *BindingClient) Delete(container *Binding) error {
+	return c.rancherClient.doResourceDelete(BINDING_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_blkio_device_option.go

@@ -0,0 +1,87 @@
+package client
+
+const (
+	BLKIO_DEVICE_OPTION_TYPE = "blkioDeviceOption"
+)
+
+type BlkioDeviceOption struct {
+	Resource
+
+	ReadBps int64 `json:"readBps,omitempty" yaml:"read_bps,omitempty"`
+
+	ReadIops int64 `json:"readIops,omitempty" yaml:"read_iops,omitempty"`
+
+	Weight int64 `json:"weight,omitempty" yaml:"weight,omitempty"`
+
+	WriteBps int64 `json:"writeBps,omitempty" yaml:"write_bps,omitempty"`
+
+	WriteIops int64 `json:"writeIops,omitempty" yaml:"write_iops,omitempty"`
+}
+
+type BlkioDeviceOptionCollection struct {
+	Collection
+	Data   []BlkioDeviceOption `json:"data,omitempty"`
+	client *BlkioDeviceOptionClient
+}
+
+type BlkioDeviceOptionClient struct {
+	rancherClient *RancherClient
+}
+
+type BlkioDeviceOptionOperations interface {
+	List(opts *ListOpts) (*BlkioDeviceOptionCollection, error)
+	Create(opts *BlkioDeviceOption) (*BlkioDeviceOption, error)
+	Update(existing *BlkioDeviceOption, updates interface{}) (*BlkioDeviceOption, error)
+	ById(id string) (*BlkioDeviceOption, error)
+	Delete(container *BlkioDeviceOption) error
+}
+
+func newBlkioDeviceOptionClient(rancherClient *RancherClient) *BlkioDeviceOptionClient {
+	return &BlkioDeviceOptionClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *BlkioDeviceOptionClient) Create(container *BlkioDeviceOption) (*BlkioDeviceOption, error) {
+	resp := &BlkioDeviceOption{}
+	err := c.rancherClient.doCreate(BLKIO_DEVICE_OPTION_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *BlkioDeviceOptionClient) Update(existing *BlkioDeviceOption, updates interface{}) (*BlkioDeviceOption, error) {
+	resp := &BlkioDeviceOption{}
+	err := c.rancherClient.doUpdate(BLKIO_DEVICE_OPTION_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *BlkioDeviceOptionClient) List(opts *ListOpts) (*BlkioDeviceOptionCollection, error) {
+	resp := &BlkioDeviceOptionCollection{}
+	err := c.rancherClient.doList(BLKIO_DEVICE_OPTION_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *BlkioDeviceOptionCollection) Next() (*BlkioDeviceOptionCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &BlkioDeviceOptionCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *BlkioDeviceOptionClient) ById(id string) (*BlkioDeviceOption, error) {
+	resp := &BlkioDeviceOption{}
+	err := c.rancherClient.doById(BLKIO_DEVICE_OPTION_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *BlkioDeviceOptionClient) Delete(container *BlkioDeviceOption) error {
+	return c.rancherClient.doResourceDelete(BLKIO_DEVICE_OPTION_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_catalog_template.go

@@ -0,0 +1,93 @@
+package client
+
+const (
+	CATALOG_TEMPLATE_TYPE = "catalogTemplate"
+)
+
+type CatalogTemplate struct {
+	Resource
+
+	Answers map[string]interface{} `json:"answers,omitempty" yaml:"answers,omitempty"`
+
+	Binding Binding `json:"binding,omitempty" yaml:"binding,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	DockerCompose string `json:"dockerCompose,omitempty" yaml:"docker_compose,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancher_compose,omitempty"`
+
+	TemplateId string `json:"templateId,omitempty" yaml:"template_id,omitempty"`
+
+	TemplateVersionId string `json:"templateVersionId,omitempty" yaml:"template_version_id,omitempty"`
+}
+
+type CatalogTemplateCollection struct {
+	Collection
+	Data   []CatalogTemplate `json:"data,omitempty"`
+	client *CatalogTemplateClient
+}
+
+type CatalogTemplateClient struct {
+	rancherClient *RancherClient
+}
+
+type CatalogTemplateOperations interface {
+	List(opts *ListOpts) (*CatalogTemplateCollection, error)
+	Create(opts *CatalogTemplate) (*CatalogTemplate, error)
+	Update(existing *CatalogTemplate, updates interface{}) (*CatalogTemplate, error)
+	ById(id string) (*CatalogTemplate, error)
+	Delete(container *CatalogTemplate) error
+}
+
+func newCatalogTemplateClient(rancherClient *RancherClient) *CatalogTemplateClient {
+	return &CatalogTemplateClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *CatalogTemplateClient) Create(container *CatalogTemplate) (*CatalogTemplate, error) {
+	resp := &CatalogTemplate{}
+	err := c.rancherClient.doCreate(CATALOG_TEMPLATE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *CatalogTemplateClient) Update(existing *CatalogTemplate, updates interface{}) (*CatalogTemplate, error) {
+	resp := &CatalogTemplate{}
+	err := c.rancherClient.doUpdate(CATALOG_TEMPLATE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *CatalogTemplateClient) List(opts *ListOpts) (*CatalogTemplateCollection, error) {
+	resp := &CatalogTemplateCollection{}
+	err := c.rancherClient.doList(CATALOG_TEMPLATE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *CatalogTemplateCollection) Next() (*CatalogTemplateCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &CatalogTemplateCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *CatalogTemplateClient) ById(id string) (*CatalogTemplate, error) {
+	resp := &CatalogTemplate{}
+	err := c.rancherClient.doById(CATALOG_TEMPLATE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *CatalogTemplateClient) Delete(container *CatalogTemplate) error {
+	return c.rancherClient.doResourceDelete(CATALOG_TEMPLATE_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_certificate.go

@@ -0,0 +1,162 @@
+package client
+
+const (
+	CERTIFICATE_TYPE = "certificate"
+)
+
+type Certificate struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Algorithm string `json:"algorithm,omitempty" yaml:"algorithm,omitempty"`
+
+	CN string `json:"cN,omitempty" yaml:"cn,omitempty"`
+
+	Cert string `json:"cert,omitempty" yaml:"cert,omitempty"`
+
+	CertChain string `json:"certChain,omitempty" yaml:"cert_chain,omitempty"`
+
+	CertFingerprint string `json:"certFingerprint,omitempty" yaml:"cert_fingerprint,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExpiresAt string `json:"expiresAt,omitempty" yaml:"expires_at,omitempty"`
+
+	IssuedAt string `json:"issuedAt,omitempty" yaml:"issued_at,omitempty"`
+
+	Issuer string `json:"issuer,omitempty" yaml:"issuer,omitempty"`
+
+	Key string `json:"key,omitempty" yaml:"key,omitempty"`
+
+	KeySize int64 `json:"keySize,omitempty" yaml:"key_size,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	SerialNumber string `json:"serialNumber,omitempty" yaml:"serial_number,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	SubjectAlternativeNames []string `json:"subjectAlternativeNames,omitempty" yaml:"subject_alternative_names,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Version string `json:"version,omitempty" yaml:"version,omitempty"`
+}
+
+type CertificateCollection struct {
+	Collection
+	Data   []Certificate `json:"data,omitempty"`
+	client *CertificateClient
+}
+
+type CertificateClient struct {
+	rancherClient *RancherClient
+}
+
+type CertificateOperations interface {
+	List(opts *ListOpts) (*CertificateCollection, error)
+	Create(opts *Certificate) (*Certificate, error)
+	Update(existing *Certificate, updates interface{}) (*Certificate, error)
+	ById(id string) (*Certificate, error)
+	Delete(container *Certificate) error
+
+	ActionCreate(*Certificate) (*Certificate, error)
+
+	ActionRemove(*Certificate) (*Certificate, error)
+
+	ActionUpdate(*Certificate) (*Certificate, error)
+}
+
+func newCertificateClient(rancherClient *RancherClient) *CertificateClient {
+	return &CertificateClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *CertificateClient) Create(container *Certificate) (*Certificate, error) {
+	resp := &Certificate{}
+	err := c.rancherClient.doCreate(CERTIFICATE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *CertificateClient) Update(existing *Certificate, updates interface{}) (*Certificate, error) {
+	resp := &Certificate{}
+	err := c.rancherClient.doUpdate(CERTIFICATE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *CertificateClient) List(opts *ListOpts) (*CertificateCollection, error) {
+	resp := &CertificateCollection{}
+	err := c.rancherClient.doList(CERTIFICATE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *CertificateCollection) Next() (*CertificateCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &CertificateCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *CertificateClient) ById(id string) (*Certificate, error) {
+	resp := &Certificate{}
+	err := c.rancherClient.doById(CERTIFICATE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *CertificateClient) Delete(container *Certificate) error {
+	return c.rancherClient.doResourceDelete(CERTIFICATE_TYPE, &container.Resource)
+}
+
+func (c *CertificateClient) ActionCreate(resource *Certificate) (*Certificate, error) {
+
+	resp := &Certificate{}
+
+	err := c.rancherClient.doAction(CERTIFICATE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *CertificateClient) ActionRemove(resource *Certificate) (*Certificate, error) {
+
+	resp := &Certificate{}
+
+	err := c.rancherClient.doAction(CERTIFICATE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *CertificateClient) ActionUpdate(resource *Certificate) (*Certificate, error) {
+
+	resp := &Certificate{}
+
+	err := c.rancherClient.doAction(CERTIFICATE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_change_secret_input.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	CHANGE_SECRET_INPUT_TYPE = "changeSecretInput"
+)
+
+type ChangeSecretInput struct {
+	Resource
+
+	NewSecret string `json:"newSecret,omitempty" yaml:"new_secret,omitempty"`
+
+	OldSecret string `json:"oldSecret,omitempty" yaml:"old_secret,omitempty"`
+}
+
+type ChangeSecretInputCollection struct {
+	Collection
+	Data   []ChangeSecretInput `json:"data,omitempty"`
+	client *ChangeSecretInputClient
+}
+
+type ChangeSecretInputClient struct {
+	rancherClient *RancherClient
+}
+
+type ChangeSecretInputOperations interface {
+	List(opts *ListOpts) (*ChangeSecretInputCollection, error)
+	Create(opts *ChangeSecretInput) (*ChangeSecretInput, error)
+	Update(existing *ChangeSecretInput, updates interface{}) (*ChangeSecretInput, error)
+	ById(id string) (*ChangeSecretInput, error)
+	Delete(container *ChangeSecretInput) error
+}
+
+func newChangeSecretInputClient(rancherClient *RancherClient) *ChangeSecretInputClient {
+	return &ChangeSecretInputClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ChangeSecretInputClient) Create(container *ChangeSecretInput) (*ChangeSecretInput, error) {
+	resp := &ChangeSecretInput{}
+	err := c.rancherClient.doCreate(CHANGE_SECRET_INPUT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ChangeSecretInputClient) Update(existing *ChangeSecretInput, updates interface{}) (*ChangeSecretInput, error) {
+	resp := &ChangeSecretInput{}
+	err := c.rancherClient.doUpdate(CHANGE_SECRET_INPUT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ChangeSecretInputClient) List(opts *ListOpts) (*ChangeSecretInputCollection, error) {
+	resp := &ChangeSecretInputCollection{}
+	err := c.rancherClient.doList(CHANGE_SECRET_INPUT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ChangeSecretInputCollection) Next() (*ChangeSecretInputCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ChangeSecretInputCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ChangeSecretInputClient) ById(id string) (*ChangeSecretInput, error) {
+	resp := &ChangeSecretInput{}
+	err := c.rancherClient.doById(CHANGE_SECRET_INPUT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ChangeSecretInputClient) Delete(container *ChangeSecretInput) error {
+	return c.rancherClient.doResourceDelete(CHANGE_SECRET_INPUT_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_client.go

@@ -0,0 +1,353 @@
+package client
+
+type RancherClient struct {
+	RancherBaseClient
+
+	Account                                  AccountOperations
+	ActiveSetting                            ActiveSettingOperations
+	AddOutputsInput                          AddOutputsInputOperations
+	AddRemoveServiceLinkInput                AddRemoveServiceLinkInputOperations
+	Agent                                    AgentOperations
+	Amazonec2Config                          Amazonec2ConfigOperations
+	ApiKey                                   ApiKeyOperations
+	AuditLog                                 AuditLogOperations
+	AzureConfig                              AzureConfigOperations
+	Azureadconfig                            AzureadconfigOperations
+	Backup                                   BackupOperations
+	BackupTarget                             BackupTargetOperations
+	BaseMachineConfig                        BaseMachineConfigOperations
+	Binding                                  BindingOperations
+	BlkioDeviceOption                        BlkioDeviceOptionOperations
+	CatalogTemplate                          CatalogTemplateOperations
+	Certificate                              CertificateOperations
+	ChangeSecretInput                        ChangeSecretInputOperations
+	ClusterMembership                        ClusterMembershipOperations
+	ComposeConfig                            ComposeConfigOperations
+	ComposeConfigInput                       ComposeConfigInputOperations
+	ComposeProject                           ComposeProjectOperations
+	ComposeService                           ComposeServiceOperations
+	ConfigItem                               ConfigItemOperations
+	ConfigItemStatus                         ConfigItemStatusOperations
+	Container                                ContainerOperations
+	ContainerEvent                           ContainerEventOperations
+	ContainerExec                            ContainerExecOperations
+	ContainerLogs                            ContainerLogsOperations
+	ContainerProxy                           ContainerProxyOperations
+	Credential                               CredentialOperations
+	Databasechangelog                        DatabasechangelogOperations
+	Databasechangeloglock                    DatabasechangeloglockOperations
+	DefaultNetwork                           DefaultNetworkOperations
+	DigitaloceanConfig                       DigitaloceanConfigOperations
+	DnsService                               DnsServiceOperations
+	DockerBuild                              DockerBuildOperations
+	ExtensionImplementation                  ExtensionImplementationOperations
+	ExtensionPoint                           ExtensionPointOperations
+	ExternalDnsEvent                         ExternalDnsEventOperations
+	ExternalEvent                            ExternalEventOperations
+	ExternalHandler                          ExternalHandlerOperations
+	ExternalHandlerExternalHandlerProcessMap ExternalHandlerExternalHandlerProcessMapOperations
+	ExternalHandlerProcess                   ExternalHandlerProcessOperations
+	ExternalHandlerProcessConfig             ExternalHandlerProcessConfigOperations
+	ExternalHostEvent                        ExternalHostEventOperations
+	ExternalService                          ExternalServiceOperations
+	ExternalServiceEvent                     ExternalServiceEventOperations
+	ExternalStoragePoolEvent                 ExternalStoragePoolEventOperations
+	ExternalVolumeEvent                      ExternalVolumeEventOperations
+	FieldDocumentation                       FieldDocumentationOperations
+	GenericObject                            GenericObjectOperations
+	HaConfig                                 HaConfigOperations
+	HaConfigInput                            HaConfigInputOperations
+	HealthcheckInstanceHostMap               HealthcheckInstanceHostMapOperations
+	Host                                     HostOperations
+	HostAccess                               HostAccessOperations
+	HostApiProxyToken                        HostApiProxyTokenOperations
+	HostTemplate                             HostTemplateOperations
+	Identity                                 IdentityOperations
+	Image                                    ImageOperations
+	InServiceUpgradeStrategy                 InServiceUpgradeStrategyOperations
+	Instance                                 InstanceOperations
+	InstanceConsole                          InstanceConsoleOperations
+	InstanceConsoleInput                     InstanceConsoleInputOperations
+	InstanceHealthCheck                      InstanceHealthCheckOperations
+	InstanceLink                             InstanceLinkOperations
+	InstanceStop                             InstanceStopOperations
+	IpAddress                                IpAddressOperations
+	KubernetesService                        KubernetesServiceOperations
+	KubernetesStack                          KubernetesStackOperations
+	KubernetesStackUpgrade                   KubernetesStackUpgradeOperations
+	Label                                    LabelOperations
+	LaunchConfig                             LaunchConfigOperations
+	LbConfig                                 LbConfigOperations
+	LbTargetConfig                           LbTargetConfigOperations
+	LoadBalancerCookieStickinessPolicy       LoadBalancerCookieStickinessPolicyOperations
+	LoadBalancerService                      LoadBalancerServiceOperations
+	LocalAuthConfig                          LocalAuthConfigOperations
+	LogConfig                                LogConfigOperations
+	Machine                                  MachineOperations
+	MachineDriver                            MachineDriverOperations
+	Mount                                    MountOperations
+	MountEntry                               MountEntryOperations
+	Network                                  NetworkOperations
+	NetworkDriver                            NetworkDriverOperations
+	NetworkDriverService                     NetworkDriverServiceOperations
+	NetworkPolicyRule                        NetworkPolicyRuleOperations
+	NetworkPolicyRuleBetween                 NetworkPolicyRuleBetweenOperations
+	NetworkPolicyRuleMember                  NetworkPolicyRuleMemberOperations
+	NetworkPolicyRuleWithin                  NetworkPolicyRuleWithinOperations
+	NfsConfig                                NfsConfigOperations
+	Openldapconfig                           OpenldapconfigOperations
+	PacketConfig                             PacketConfigOperations
+	Password                                 PasswordOperations
+	PhysicalHost                             PhysicalHostOperations
+	Port                                     PortOperations
+	PortRule                                 PortRuleOperations
+	ProcessDefinition                        ProcessDefinitionOperations
+	ProcessExecution                         ProcessExecutionOperations
+	ProcessInstance                          ProcessInstanceOperations
+	ProcessPool                              ProcessPoolOperations
+	ProcessSummary                           ProcessSummaryOperations
+	Project                                  ProjectOperations
+	ProjectMember                            ProjectMemberOperations
+	ProjectTemplate                          ProjectTemplateOperations
+	PublicEndpoint                           PublicEndpointOperations
+	Publish                                  PublishOperations
+	PullTask                                 PullTaskOperations
+	RecreateOnQuorumStrategyConfig           RecreateOnQuorumStrategyConfigOperations
+	Register                                 RegisterOperations
+	RegistrationToken                        RegistrationTokenOperations
+	Registry                                 RegistryOperations
+	RegistryCredential                       RegistryCredentialOperations
+	ResourceDefinition                       ResourceDefinitionOperations
+	RestartPolicy                            RestartPolicyOperations
+	RestoreFromBackupInput                   RestoreFromBackupInputOperations
+	RevertToSnapshotInput                    RevertToSnapshotInputOperations
+	RollingRestartStrategy                   RollingRestartStrategyOperations
+	ScalePolicy                              ScalePolicyOperations
+	ScheduledUpgrade                         ScheduledUpgradeOperations
+	SecondaryLaunchConfig                    SecondaryLaunchConfigOperations
+	Secret                                   SecretOperations
+	SecretReference                          SecretReferenceOperations
+	Service                                  ServiceOperations
+	ServiceBinding                           ServiceBindingOperations
+	ServiceConsumeMap                        ServiceConsumeMapOperations
+	ServiceEvent                             ServiceEventOperations
+	ServiceExposeMap                         ServiceExposeMapOperations
+	ServiceLink                              ServiceLinkOperations
+	ServiceLog                               ServiceLogOperations
+	ServiceProxy                             ServiceProxyOperations
+	ServiceRestart                           ServiceRestartOperations
+	ServiceUpgrade                           ServiceUpgradeOperations
+	ServiceUpgradeStrategy                   ServiceUpgradeStrategyOperations
+	ServicesPortRange                        ServicesPortRangeOperations
+	SetProjectMembersInput                   SetProjectMembersInputOperations
+	SetServiceLinksInput                     SetServiceLinksInputOperations
+	Setting                                  SettingOperations
+	Snapshot                                 SnapshotOperations
+	SnapshotBackupInput                      SnapshotBackupInputOperations
+	Stack                                    StackOperations
+	StackUpgrade                             StackUpgradeOperations
+	StateTransition                          StateTransitionOperations
+	StatsAccess                              StatsAccessOperations
+	StorageDriver                            StorageDriverOperations
+	StorageDriverService                     StorageDriverServiceOperations
+	StoragePool                              StoragePoolOperations
+	Subnet                                   SubnetOperations
+	TargetPortRule                           TargetPortRuleOperations
+	Task                                     TaskOperations
+	TaskInstance                             TaskInstanceOperations
+	ToServiceUpgradeStrategy                 ToServiceUpgradeStrategyOperations
+	TypeDocumentation                        TypeDocumentationOperations
+	Ulimit                                   UlimitOperations
+	UserPreference                           UserPreferenceOperations
+	VirtualMachine                           VirtualMachineOperations
+	VirtualMachineDisk                       VirtualMachineDiskOperations
+	Volume                                   VolumeOperations
+	VolumeActivateInput                      VolumeActivateInputOperations
+	VolumeSnapshotInput                      VolumeSnapshotInputOperations
+	VolumeTemplate                           VolumeTemplateOperations
+}
+
+func constructClient(rancherBaseClient *RancherBaseClientImpl) *RancherClient {
+	client := &RancherClient{
+		RancherBaseClient: rancherBaseClient,
+	}
+
+	client.Account = newAccountClient(client)
+	client.ActiveSetting = newActiveSettingClient(client)
+	client.AddOutputsInput = newAddOutputsInputClient(client)
+	client.AddRemoveServiceLinkInput = newAddRemoveServiceLinkInputClient(client)
+	client.Agent = newAgentClient(client)
+	client.Amazonec2Config = newAmazonec2ConfigClient(client)
+	client.ApiKey = newApiKeyClient(client)
+	client.AuditLog = newAuditLogClient(client)
+	client.AzureConfig = newAzureConfigClient(client)
+	client.Azureadconfig = newAzureadconfigClient(client)
+	client.Backup = newBackupClient(client)
+	client.BackupTarget = newBackupTargetClient(client)
+	client.BaseMachineConfig = newBaseMachineConfigClient(client)
+	client.Binding = newBindingClient(client)
+	client.BlkioDeviceOption = newBlkioDeviceOptionClient(client)
+	client.CatalogTemplate = newCatalogTemplateClient(client)
+	client.Certificate = newCertificateClient(client)
+	client.ChangeSecretInput = newChangeSecretInputClient(client)
+	client.ClusterMembership = newClusterMembershipClient(client)
+	client.ComposeConfig = newComposeConfigClient(client)
+	client.ComposeConfigInput = newComposeConfigInputClient(client)
+	client.ComposeProject = newComposeProjectClient(client)
+	client.ComposeService = newComposeServiceClient(client)
+	client.ConfigItem = newConfigItemClient(client)
+	client.ConfigItemStatus = newConfigItemStatusClient(client)
+	client.Container = newContainerClient(client)
+	client.ContainerEvent = newContainerEventClient(client)
+	client.ContainerExec = newContainerExecClient(client)
+	client.ContainerLogs = newContainerLogsClient(client)
+	client.ContainerProxy = newContainerProxyClient(client)
+	client.Credential = newCredentialClient(client)
+	client.Databasechangelog = newDatabasechangelogClient(client)
+	client.Databasechangeloglock = newDatabasechangeloglockClient(client)
+	client.DefaultNetwork = newDefaultNetworkClient(client)
+	client.DigitaloceanConfig = newDigitaloceanConfigClient(client)
+	client.DnsService = newDnsServiceClient(client)
+	client.DockerBuild = newDockerBuildClient(client)
+	client.ExtensionImplementation = newExtensionImplementationClient(client)
+	client.ExtensionPoint = newExtensionPointClient(client)
+	client.ExternalDnsEvent = newExternalDnsEventClient(client)
+	client.ExternalEvent = newExternalEventClient(client)
+	client.ExternalHandler = newExternalHandlerClient(client)
+	client.ExternalHandlerExternalHandlerProcessMap = newExternalHandlerExternalHandlerProcessMapClient(client)
+	client.ExternalHandlerProcess = newExternalHandlerProcessClient(client)
+	client.ExternalHandlerProcessConfig = newExternalHandlerProcessConfigClient(client)
+	client.ExternalHostEvent = newExternalHostEventClient(client)
+	client.ExternalService = newExternalServiceClient(client)
+	client.ExternalServiceEvent = newExternalServiceEventClient(client)
+	client.ExternalStoragePoolEvent = newExternalStoragePoolEventClient(client)
+	client.ExternalVolumeEvent = newExternalVolumeEventClient(client)
+	client.FieldDocumentation = newFieldDocumentationClient(client)
+	client.GenericObject = newGenericObjectClient(client)
+	client.HaConfig = newHaConfigClient(client)
+	client.HaConfigInput = newHaConfigInputClient(client)
+	client.HealthcheckInstanceHostMap = newHealthcheckInstanceHostMapClient(client)
+	client.Host = newHostClient(client)
+	client.HostAccess = newHostAccessClient(client)
+	client.HostApiProxyToken = newHostApiProxyTokenClient(client)
+	client.HostTemplate = newHostTemplateClient(client)
+	client.Identity = newIdentityClient(client)
+	client.Image = newImageClient(client)
+	client.InServiceUpgradeStrategy = newInServiceUpgradeStrategyClient(client)
+	client.Instance = newInstanceClient(client)
+	client.InstanceConsole = newInstanceConsoleClient(client)
+	client.InstanceConsoleInput = newInstanceConsoleInputClient(client)
+	client.InstanceHealthCheck = newInstanceHealthCheckClient(client)
+	client.InstanceLink = newInstanceLinkClient(client)
+	client.InstanceStop = newInstanceStopClient(client)
+	client.IpAddress = newIpAddressClient(client)
+	client.KubernetesService = newKubernetesServiceClient(client)
+	client.KubernetesStack = newKubernetesStackClient(client)
+	client.KubernetesStackUpgrade = newKubernetesStackUpgradeClient(client)
+	client.Label = newLabelClient(client)
+	client.LaunchConfig = newLaunchConfigClient(client)
+	client.LbConfig = newLbConfigClient(client)
+	client.LbTargetConfig = newLbTargetConfigClient(client)
+	client.LoadBalancerCookieStickinessPolicy = newLoadBalancerCookieStickinessPolicyClient(client)
+	client.LoadBalancerService = newLoadBalancerServiceClient(client)
+	client.LocalAuthConfig = newLocalAuthConfigClient(client)
+	client.LogConfig = newLogConfigClient(client)
+	client.Machine = newMachineClient(client)
+	client.MachineDriver = newMachineDriverClient(client)
+	client.Mount = newMountClient(client)
+	client.MountEntry = newMountEntryClient(client)
+	client.Network = newNetworkClient(client)
+	client.NetworkDriver = newNetworkDriverClient(client)
+	client.NetworkDriverService = newNetworkDriverServiceClient(client)
+	client.NetworkPolicyRule = newNetworkPolicyRuleClient(client)
+	client.NetworkPolicyRuleBetween = newNetworkPolicyRuleBetweenClient(client)
+	client.NetworkPolicyRuleMember = newNetworkPolicyRuleMemberClient(client)
+	client.NetworkPolicyRuleWithin = newNetworkPolicyRuleWithinClient(client)
+	client.NfsConfig = newNfsConfigClient(client)
+	client.Openldapconfig = newOpenldapconfigClient(client)
+	client.PacketConfig = newPacketConfigClient(client)
+	client.Password = newPasswordClient(client)
+	client.PhysicalHost = newPhysicalHostClient(client)
+	client.Port = newPortClient(client)
+	client.PortRule = newPortRuleClient(client)
+	client.ProcessDefinition = newProcessDefinitionClient(client)
+	client.ProcessExecution = newProcessExecutionClient(client)
+	client.ProcessInstance = newProcessInstanceClient(client)
+	client.ProcessPool = newProcessPoolClient(client)
+	client.ProcessSummary = newProcessSummaryClient(client)
+	client.Project = newProjectClient(client)
+	client.ProjectMember = newProjectMemberClient(client)
+	client.ProjectTemplate = newProjectTemplateClient(client)
+	client.PublicEndpoint = newPublicEndpointClient(client)
+	client.Publish = newPublishClient(client)
+	client.PullTask = newPullTaskClient(client)
+	client.RecreateOnQuorumStrategyConfig = newRecreateOnQuorumStrategyConfigClient(client)
+	client.Register = newRegisterClient(client)
+	client.RegistrationToken = newRegistrationTokenClient(client)
+	client.Registry = newRegistryClient(client)
+	client.RegistryCredential = newRegistryCredentialClient(client)
+	client.ResourceDefinition = newResourceDefinitionClient(client)
+	client.RestartPolicy = newRestartPolicyClient(client)
+	client.RestoreFromBackupInput = newRestoreFromBackupInputClient(client)
+	client.RevertToSnapshotInput = newRevertToSnapshotInputClient(client)
+	client.RollingRestartStrategy = newRollingRestartStrategyClient(client)
+	client.ScalePolicy = newScalePolicyClient(client)
+	client.ScheduledUpgrade = newScheduledUpgradeClient(client)
+	client.SecondaryLaunchConfig = newSecondaryLaunchConfigClient(client)
+	client.Secret = newSecretClient(client)
+	client.SecretReference = newSecretReferenceClient(client)
+	client.Service = newServiceClient(client)
+	client.ServiceBinding = newServiceBindingClient(client)
+	client.ServiceConsumeMap = newServiceConsumeMapClient(client)
+	client.ServiceEvent = newServiceEventClient(client)
+	client.ServiceExposeMap = newServiceExposeMapClient(client)
+	client.ServiceLink = newServiceLinkClient(client)
+	client.ServiceLog = newServiceLogClient(client)
+	client.ServiceProxy = newServiceProxyClient(client)
+	client.ServiceRestart = newServiceRestartClient(client)
+	client.ServiceUpgrade = newServiceUpgradeClient(client)
+	client.ServiceUpgradeStrategy = newServiceUpgradeStrategyClient(client)
+	client.ServicesPortRange = newServicesPortRangeClient(client)
+	client.SetProjectMembersInput = newSetProjectMembersInputClient(client)
+	client.SetServiceLinksInput = newSetServiceLinksInputClient(client)
+	client.Setting = newSettingClient(client)
+	client.Snapshot = newSnapshotClient(client)
+	client.SnapshotBackupInput = newSnapshotBackupInputClient(client)
+	client.Stack = newStackClient(client)
+	client.StackUpgrade = newStackUpgradeClient(client)
+	client.StateTransition = newStateTransitionClient(client)
+	client.StatsAccess = newStatsAccessClient(client)
+	client.StorageDriver = newStorageDriverClient(client)
+	client.StorageDriverService = newStorageDriverServiceClient(client)
+	client.StoragePool = newStoragePoolClient(client)
+	client.Subnet = newSubnetClient(client)
+	client.TargetPortRule = newTargetPortRuleClient(client)
+	client.Task = newTaskClient(client)
+	client.TaskInstance = newTaskInstanceClient(client)
+	client.ToServiceUpgradeStrategy = newToServiceUpgradeStrategyClient(client)
+	client.TypeDocumentation = newTypeDocumentationClient(client)
+	client.Ulimit = newUlimitClient(client)
+	client.UserPreference = newUserPreferenceClient(client)
+	client.VirtualMachine = newVirtualMachineClient(client)
+	client.VirtualMachineDisk = newVirtualMachineDiskClient(client)
+	client.Volume = newVolumeClient(client)
+	client.VolumeActivateInput = newVolumeActivateInputClient(client)
+	client.VolumeSnapshotInput = newVolumeSnapshotInputClient(client)
+	client.VolumeTemplate = newVolumeTemplateClient(client)
+
+	return client
+}
+
+func NewRancherClient(opts *ClientOpts) (*RancherClient, error) {
+	rancherBaseClient := &RancherBaseClientImpl{
+		Types: map[string]Schema{},
+	}
+	client := constructClient(rancherBaseClient)
+
+	err := setupRancherBaseClient(rancherBaseClient, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return client, nil
+}

vendor/github.com/rancher/go-rancher/v2/generated_cluster_membership.go

@@ -0,0 +1,87 @@
+package client
+
+const (
+	CLUSTER_MEMBERSHIP_TYPE = "clusterMembership"
+)
+
+type ClusterMembership struct {
+	Resource
+
+	Clustered bool `json:"clustered,omitempty" yaml:"clustered,omitempty"`
+
+	Config string `json:"config,omitempty" yaml:"config,omitempty"`
+
+	Heartbeat int64 `json:"heartbeat,omitempty" yaml:"heartbeat,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ClusterMembershipCollection struct {
+	Collection
+	Data   []ClusterMembership `json:"data,omitempty"`
+	client *ClusterMembershipClient
+}
+
+type ClusterMembershipClient struct {
+	rancherClient *RancherClient
+}
+
+type ClusterMembershipOperations interface {
+	List(opts *ListOpts) (*ClusterMembershipCollection, error)
+	Create(opts *ClusterMembership) (*ClusterMembership, error)
+	Update(existing *ClusterMembership, updates interface{}) (*ClusterMembership, error)
+	ById(id string) (*ClusterMembership, error)
+	Delete(container *ClusterMembership) error
+}
+
+func newClusterMembershipClient(rancherClient *RancherClient) *ClusterMembershipClient {
+	return &ClusterMembershipClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ClusterMembershipClient) Create(container *ClusterMembership) (*ClusterMembership, error) {
+	resp := &ClusterMembership{}
+	err := c.rancherClient.doCreate(CLUSTER_MEMBERSHIP_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ClusterMembershipClient) Update(existing *ClusterMembership, updates interface{}) (*ClusterMembership, error) {
+	resp := &ClusterMembership{}
+	err := c.rancherClient.doUpdate(CLUSTER_MEMBERSHIP_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ClusterMembershipClient) List(opts *ListOpts) (*ClusterMembershipCollection, error) {
+	resp := &ClusterMembershipCollection{}
+	err := c.rancherClient.doList(CLUSTER_MEMBERSHIP_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ClusterMembershipCollection) Next() (*ClusterMembershipCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ClusterMembershipCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ClusterMembershipClient) ById(id string) (*ClusterMembership, error) {
+	resp := &ClusterMembership{}
+	err := c.rancherClient.doById(CLUSTER_MEMBERSHIP_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ClusterMembershipClient) Delete(container *ClusterMembership) error {
+	return c.rancherClient.doResourceDelete(CLUSTER_MEMBERSHIP_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_compose_config.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	COMPOSE_CONFIG_TYPE = "composeConfig"
+)
+
+type ComposeConfig struct {
+	Resource
+
+	DockerComposeConfig string `json:"dockerComposeConfig,omitempty" yaml:"docker_compose_config,omitempty"`
+
+	RancherComposeConfig string `json:"rancherComposeConfig,omitempty" yaml:"rancher_compose_config,omitempty"`
+}
+
+type ComposeConfigCollection struct {
+	Collection
+	Data   []ComposeConfig `json:"data,omitempty"`
+	client *ComposeConfigClient
+}
+
+type ComposeConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type ComposeConfigOperations interface {
+	List(opts *ListOpts) (*ComposeConfigCollection, error)
+	Create(opts *ComposeConfig) (*ComposeConfig, error)
+	Update(existing *ComposeConfig, updates interface{}) (*ComposeConfig, error)
+	ById(id string) (*ComposeConfig, error)
+	Delete(container *ComposeConfig) error
+}
+
+func newComposeConfigClient(rancherClient *RancherClient) *ComposeConfigClient {
+	return &ComposeConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ComposeConfigClient) Create(container *ComposeConfig) (*ComposeConfig, error) {
+	resp := &ComposeConfig{}
+	err := c.rancherClient.doCreate(COMPOSE_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ComposeConfigClient) Update(existing *ComposeConfig, updates interface{}) (*ComposeConfig, error) {
+	resp := &ComposeConfig{}
+	err := c.rancherClient.doUpdate(COMPOSE_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ComposeConfigClient) List(opts *ListOpts) (*ComposeConfigCollection, error) {
+	resp := &ComposeConfigCollection{}
+	err := c.rancherClient.doList(COMPOSE_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ComposeConfigCollection) Next() (*ComposeConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ComposeConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ComposeConfigClient) ById(id string) (*ComposeConfig, error) {
+	resp := &ComposeConfig{}
+	err := c.rancherClient.doById(COMPOSE_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ComposeConfigClient) Delete(container *ComposeConfig) error {
+	return c.rancherClient.doResourceDelete(COMPOSE_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_compose_config_input.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	COMPOSE_CONFIG_INPUT_TYPE = "composeConfigInput"
+)
+
+type ComposeConfigInput struct {
+	Resource
+
+	ServiceIds []string `json:"serviceIds,omitempty" yaml:"service_ids,omitempty"`
+}
+
+type ComposeConfigInputCollection struct {
+	Collection
+	Data   []ComposeConfigInput `json:"data,omitempty"`
+	client *ComposeConfigInputClient
+}
+
+type ComposeConfigInputClient struct {
+	rancherClient *RancherClient
+}
+
+type ComposeConfigInputOperations interface {
+	List(opts *ListOpts) (*ComposeConfigInputCollection, error)
+	Create(opts *ComposeConfigInput) (*ComposeConfigInput, error)
+	Update(existing *ComposeConfigInput, updates interface{}) (*ComposeConfigInput, error)
+	ById(id string) (*ComposeConfigInput, error)
+	Delete(container *ComposeConfigInput) error
+}
+
+func newComposeConfigInputClient(rancherClient *RancherClient) *ComposeConfigInputClient {
+	return &ComposeConfigInputClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ComposeConfigInputClient) Create(container *ComposeConfigInput) (*ComposeConfigInput, error) {
+	resp := &ComposeConfigInput{}
+	err := c.rancherClient.doCreate(COMPOSE_CONFIG_INPUT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ComposeConfigInputClient) Update(existing *ComposeConfigInput, updates interface{}) (*ComposeConfigInput, error) {
+	resp := &ComposeConfigInput{}
+	err := c.rancherClient.doUpdate(COMPOSE_CONFIG_INPUT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ComposeConfigInputClient) List(opts *ListOpts) (*ComposeConfigInputCollection, error) {
+	resp := &ComposeConfigInputCollection{}
+	err := c.rancherClient.doList(COMPOSE_CONFIG_INPUT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ComposeConfigInputCollection) Next() (*ComposeConfigInputCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ComposeConfigInputCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ComposeConfigInputClient) ById(id string) (*ComposeConfigInput, error) {
+	resp := &ComposeConfigInput{}
+	err := c.rancherClient.doById(COMPOSE_CONFIG_INPUT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ComposeConfigInputClient) Delete(container *ComposeConfigInput) error {
+	return c.rancherClient.doResourceDelete(COMPOSE_CONFIG_INPUT_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_compose_project.go

@@ -0,0 +1,191 @@
+package client
+
+const (
+	COMPOSE_PROJECT_TYPE = "composeProject"
+)
+
+type ComposeProject struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Answers map[string]interface{} `json:"answers,omitempty" yaml:"answers,omitempty"`
+
+	Binding *Binding `json:"binding,omitempty" yaml:"binding,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Group string `json:"group,omitempty" yaml:"group,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PreviousEnvironment map[string]interface{} `json:"previousEnvironment,omitempty" yaml:"previous_environment,omitempty"`
+
+	PreviousExternalId string `json:"previousExternalId,omitempty" yaml:"previous_external_id,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	ServiceIds []string `json:"serviceIds,omitempty" yaml:"service_ids,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Templates map[string]interface{} `json:"templates,omitempty" yaml:"templates,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ComposeProjectCollection struct {
+	Collection
+	Data   []ComposeProject `json:"data,omitempty"`
+	client *ComposeProjectClient
+}
+
+type ComposeProjectClient struct {
+	rancherClient *RancherClient
+}
+
+type ComposeProjectOperations interface {
+	List(opts *ListOpts) (*ComposeProjectCollection, error)
+	Create(opts *ComposeProject) (*ComposeProject, error)
+	Update(existing *ComposeProject, updates interface{}) (*ComposeProject, error)
+	ById(id string) (*ComposeProject, error)
+	Delete(container *ComposeProject) error
+
+	ActionCancelupgrade(*ComposeProject) (*Stack, error)
+
+	ActionCreate(*ComposeProject) (*Stack, error)
+
+	ActionError(*ComposeProject) (*Stack, error)
+
+	ActionFinishupgrade(*ComposeProject) (*Stack, error)
+
+	ActionRemove(*ComposeProject) (*Stack, error)
+
+	ActionRollback(*ComposeProject) (*Stack, error)
+}
+
+func newComposeProjectClient(rancherClient *RancherClient) *ComposeProjectClient {
+	return &ComposeProjectClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ComposeProjectClient) Create(container *ComposeProject) (*ComposeProject, error) {
+	resp := &ComposeProject{}
+	err := c.rancherClient.doCreate(COMPOSE_PROJECT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ComposeProjectClient) Update(existing *ComposeProject, updates interface{}) (*ComposeProject, error) {
+	resp := &ComposeProject{}
+	err := c.rancherClient.doUpdate(COMPOSE_PROJECT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ComposeProjectClient) List(opts *ListOpts) (*ComposeProjectCollection, error) {
+	resp := &ComposeProjectCollection{}
+	err := c.rancherClient.doList(COMPOSE_PROJECT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ComposeProjectCollection) Next() (*ComposeProjectCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ComposeProjectCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ComposeProjectClient) ById(id string) (*ComposeProject, error) {
+	resp := &ComposeProject{}
+	err := c.rancherClient.doById(COMPOSE_PROJECT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ComposeProjectClient) Delete(container *ComposeProject) error {
+	return c.rancherClient.doResourceDelete(COMPOSE_PROJECT_TYPE, &container.Resource)
+}
+
+func (c *ComposeProjectClient) ActionCancelupgrade(resource *ComposeProject) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeProjectClient) ActionCreate(resource *ComposeProject) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeProjectClient) ActionError(resource *ComposeProject) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeProjectClient) ActionFinishupgrade(resource *ComposeProject) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeProjectClient) ActionRemove(resource *ComposeProject) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeProjectClient) ActionRollback(resource *ComposeProject) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_compose_service.go

@@ -0,0 +1,212 @@
+package client
+
+const (
+	COMPOSE_SERVICE_TYPE = "composeService"
+)
+
+type ComposeService struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	CurrentScale int64 `json:"currentScale,omitempty" yaml:"current_scale,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	InstanceIds []string `json:"instanceIds,omitempty" yaml:"instance_ids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
+
+	LinkedServices map[string]interface{} `json:"linkedServices,omitempty" yaml:"linked_services,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PublicEndpoints []PublicEndpoint `json:"publicEndpoints,omitempty" yaml:"public_endpoints,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	Scale int64 `json:"scale,omitempty" yaml:"scale,omitempty"`
+
+	ScalePolicy *ScalePolicy `json:"scalePolicy,omitempty" yaml:"scale_policy,omitempty"`
+
+	SelectorContainer string `json:"selectorContainer,omitempty" yaml:"selector_container,omitempty"`
+
+	SelectorLink string `json:"selectorLink,omitempty" yaml:"selector_link,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Vip string `json:"vip,omitempty" yaml:"vip,omitempty"`
+}
+
+type ComposeServiceCollection struct {
+	Collection
+	Data   []ComposeService `json:"data,omitempty"`
+	client *ComposeServiceClient
+}
+
+type ComposeServiceClient struct {
+	rancherClient *RancherClient
+}
+
+type ComposeServiceOperations interface {
+	List(opts *ListOpts) (*ComposeServiceCollection, error)
+	Create(opts *ComposeService) (*ComposeService, error)
+	Update(existing *ComposeService, updates interface{}) (*ComposeService, error)
+	ById(id string) (*ComposeService, error)
+	Delete(container *ComposeService) error
+
+	ActionActivate(*ComposeService) (*Service, error)
+
+	ActionCancelupgrade(*ComposeService) (*Service, error)
+
+	ActionContinueupgrade(*ComposeService) (*Service, error)
+
+	ActionCreate(*ComposeService) (*Service, error)
+
+	ActionFinishupgrade(*ComposeService) (*Service, error)
+
+	ActionRemove(*ComposeService) (*Service, error)
+
+	ActionRollback(*ComposeService) (*Service, error)
+}
+
+func newComposeServiceClient(rancherClient *RancherClient) *ComposeServiceClient {
+	return &ComposeServiceClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ComposeServiceClient) Create(container *ComposeService) (*ComposeService, error) {
+	resp := &ComposeService{}
+	err := c.rancherClient.doCreate(COMPOSE_SERVICE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ComposeServiceClient) Update(existing *ComposeService, updates interface{}) (*ComposeService, error) {
+	resp := &ComposeService{}
+	err := c.rancherClient.doUpdate(COMPOSE_SERVICE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ComposeServiceClient) List(opts *ListOpts) (*ComposeServiceCollection, error) {
+	resp := &ComposeServiceCollection{}
+	err := c.rancherClient.doList(COMPOSE_SERVICE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ComposeServiceCollection) Next() (*ComposeServiceCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ComposeServiceCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ComposeServiceClient) ById(id string) (*ComposeService, error) {
+	resp := &ComposeService{}
+	err := c.rancherClient.doById(COMPOSE_SERVICE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ComposeServiceClient) Delete(container *ComposeService) error {
+	return c.rancherClient.doResourceDelete(COMPOSE_SERVICE_TYPE, &container.Resource)
+}
+
+func (c *ComposeServiceClient) ActionActivate(resource *ComposeService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeServiceClient) ActionCancelupgrade(resource *ComposeService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeServiceClient) ActionContinueupgrade(resource *ComposeService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "continueupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeServiceClient) ActionCreate(resource *ComposeService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeServiceClient) ActionFinishupgrade(resource *ComposeService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeServiceClient) ActionRemove(resource *ComposeService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ComposeServiceClient) ActionRollback(resource *ComposeService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_config_item.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	CONFIG_ITEM_TYPE = "configItem"
+)
+
+type ConfigItem struct {
+	Resource
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	SourceVersion string `json:"sourceVersion,omitempty" yaml:"source_version,omitempty"`
+}
+
+type ConfigItemCollection struct {
+	Collection
+	Data   []ConfigItem `json:"data,omitempty"`
+	client *ConfigItemClient
+}
+
+type ConfigItemClient struct {
+	rancherClient *RancherClient
+}
+
+type ConfigItemOperations interface {
+	List(opts *ListOpts) (*ConfigItemCollection, error)
+	Create(opts *ConfigItem) (*ConfigItem, error)
+	Update(existing *ConfigItem, updates interface{}) (*ConfigItem, error)
+	ById(id string) (*ConfigItem, error)
+	Delete(container *ConfigItem) error
+}
+
+func newConfigItemClient(rancherClient *RancherClient) *ConfigItemClient {
+	return &ConfigItemClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ConfigItemClient) Create(container *ConfigItem) (*ConfigItem, error) {
+	resp := &ConfigItem{}
+	err := c.rancherClient.doCreate(CONFIG_ITEM_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ConfigItemClient) Update(existing *ConfigItem, updates interface{}) (*ConfigItem, error) {
+	resp := &ConfigItem{}
+	err := c.rancherClient.doUpdate(CONFIG_ITEM_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ConfigItemClient) List(opts *ListOpts) (*ConfigItemCollection, error) {
+	resp := &ConfigItemCollection{}
+	err := c.rancherClient.doList(CONFIG_ITEM_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ConfigItemCollection) Next() (*ConfigItemCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ConfigItemCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ConfigItemClient) ById(id string) (*ConfigItem, error) {
+	resp := &ConfigItem{}
+	err := c.rancherClient.doById(CONFIG_ITEM_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ConfigItemClient) Delete(container *ConfigItem) error {
+	return c.rancherClient.doResourceDelete(CONFIG_ITEM_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_config_item_status.go

@@ -0,0 +1,93 @@
+package client
+
+const (
+	CONFIG_ITEM_STATUS_TYPE = "configItemStatus"
+)
+
+type ConfigItemStatus struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
+
+	AppliedUpdated string `json:"appliedUpdated,omitempty" yaml:"applied_updated,omitempty"`
+
+	AppliedVersion int64 `json:"appliedVersion,omitempty" yaml:"applied_version,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RequestedUpdated string `json:"requestedUpdated,omitempty" yaml:"requested_updated,omitempty"`
+
+	RequestedVersion int64 `json:"requestedVersion,omitempty" yaml:"requested_version,omitempty"`
+
+	SourceVersion string `json:"sourceVersion,omitempty" yaml:"source_version,omitempty"`
+}
+
+type ConfigItemStatusCollection struct {
+	Collection
+	Data   []ConfigItemStatus `json:"data,omitempty"`
+	client *ConfigItemStatusClient
+}
+
+type ConfigItemStatusClient struct {
+	rancherClient *RancherClient
+}
+
+type ConfigItemStatusOperations interface {
+	List(opts *ListOpts) (*ConfigItemStatusCollection, error)
+	Create(opts *ConfigItemStatus) (*ConfigItemStatus, error)
+	Update(existing *ConfigItemStatus, updates interface{}) (*ConfigItemStatus, error)
+	ById(id string) (*ConfigItemStatus, error)
+	Delete(container *ConfigItemStatus) error
+}
+
+func newConfigItemStatusClient(rancherClient *RancherClient) *ConfigItemStatusClient {
+	return &ConfigItemStatusClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ConfigItemStatusClient) Create(container *ConfigItemStatus) (*ConfigItemStatus, error) {
+	resp := &ConfigItemStatus{}
+	err := c.rancherClient.doCreate(CONFIG_ITEM_STATUS_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ConfigItemStatusClient) Update(existing *ConfigItemStatus, updates interface{}) (*ConfigItemStatus, error) {
+	resp := &ConfigItemStatus{}
+	err := c.rancherClient.doUpdate(CONFIG_ITEM_STATUS_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ConfigItemStatusClient) List(opts *ListOpts) (*ConfigItemStatusCollection, error) {
+	resp := &ConfigItemStatusCollection{}
+	err := c.rancherClient.doList(CONFIG_ITEM_STATUS_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ConfigItemStatusCollection) Next() (*ConfigItemStatusCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ConfigItemStatusCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ConfigItemStatusClient) ById(id string) (*ConfigItemStatus, error) {
+	resp := &ConfigItemStatus{}
+	err := c.rancherClient.doById(CONFIG_ITEM_STATUS_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ConfigItemStatusClient) Delete(container *ConfigItemStatus) error {
+	return c.rancherClient.doResourceDelete(CONFIG_ITEM_STATUS_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_container.go

@@ -0,0 +1,517 @@
+package client
+
+const (
+	CONTAINER_TYPE = "container"
+)
+
+type Container struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
+
+	AllocationState string `json:"allocationState,omitempty" yaml:"allocation_state,omitempty"`
+
+	BlkioDeviceOptions map[string]interface{} `json:"blkioDeviceOptions,omitempty" yaml:"blkio_device_options,omitempty"`
+
+	BlkioWeight int64 `json:"blkioWeight,omitempty" yaml:"blkio_weight,omitempty"`
+
+	Build *DockerBuild `json:"build,omitempty" yaml:"build,omitempty"`
+
+	CapAdd []string `json:"capAdd,omitempty" yaml:"cap_add,omitempty"`
+
+	CapDrop []string `json:"capDrop,omitempty" yaml:"cap_drop,omitempty"`
+
+	CgroupParent string `json:"cgroupParent,omitempty" yaml:"cgroup_parent,omitempty"`
+
+	Command []string `json:"command,omitempty" yaml:"command,omitempty"`
+
+	Count int64 `json:"count,omitempty" yaml:"count,omitempty"`
+
+	CpuCount int64 `json:"cpuCount,omitempty" yaml:"cpu_count,omitempty"`
+
+	CpuPercent int64 `json:"cpuPercent,omitempty" yaml:"cpu_percent,omitempty"`
+
+	CpuPeriod int64 `json:"cpuPeriod,omitempty" yaml:"cpu_period,omitempty"`
+
+	CpuQuota int64 `json:"cpuQuota,omitempty" yaml:"cpu_quota,omitempty"`
+
+	CpuRealtimePeriod int64 `json:"cpuRealtimePeriod,omitempty" yaml:"cpu_realtime_period,omitempty"`
+
+	CpuRealtimeRuntime int64 `json:"cpuRealtimeRuntime,omitempty" yaml:"cpu_realtime_runtime,omitempty"`
+
+	CpuSet string `json:"cpuSet,omitempty" yaml:"cpu_set,omitempty"`
+
+	CpuSetMems string `json:"cpuSetMems,omitempty" yaml:"cpu_set_mems,omitempty"`
+
+	CpuShares int64 `json:"cpuShares,omitempty" yaml:"cpu_shares,omitempty"`
+
+	CreateIndex int64 `json:"createIndex,omitempty" yaml:"create_index,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DataVolumeMounts map[string]interface{} `json:"dataVolumeMounts,omitempty" yaml:"data_volume_mounts,omitempty"`
+
+	DataVolumes []string `json:"dataVolumes,omitempty" yaml:"data_volumes,omitempty"`
+
+	DataVolumesFrom []string `json:"dataVolumesFrom,omitempty" yaml:"data_volumes_from,omitempty"`
+
+	DeploymentUnitUuid string `json:"deploymentUnitUuid,omitempty" yaml:"deployment_unit_uuid,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Devices []string `json:"devices,omitempty" yaml:"devices,omitempty"`
+
+	DiskQuota int64 `json:"diskQuota,omitempty" yaml:"disk_quota,omitempty"`
+
+	Dns []string `json:"dns,omitempty" yaml:"dns,omitempty"`
+
+	DnsOpt []string `json:"dnsOpt,omitempty" yaml:"dns_opt,omitempty"`
+
+	DnsSearch []string `json:"dnsSearch,omitempty" yaml:"dns_search,omitempty"`
+
+	DomainName string `json:"domainName,omitempty" yaml:"domain_name,omitempty"`
+
+	EntryPoint []string `json:"entryPoint,omitempty" yaml:"entry_point,omitempty"`
+
+	Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
+
+	Expose []string `json:"expose,omitempty" yaml:"expose,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	ExtraHosts []string `json:"extraHosts,omitempty" yaml:"extra_hosts,omitempty"`
+
+	FirstRunning string `json:"firstRunning,omitempty" yaml:"first_running,omitempty"`
+
+	GroupAdd []string `json:"groupAdd,omitempty" yaml:"group_add,omitempty"`
+
+	HealthCheck *InstanceHealthCheck `json:"healthCheck,omitempty" yaml:"health_check,omitempty"`
+
+	HealthCmd []string `json:"healthCmd,omitempty" yaml:"health_cmd,omitempty"`
+
+	HealthInterval int64 `json:"healthInterval,omitempty" yaml:"health_interval,omitempty"`
+
+	HealthRetries int64 `json:"healthRetries,omitempty" yaml:"health_retries,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	HealthTimeout int64 `json:"healthTimeout,omitempty" yaml:"health_timeout,omitempty"`
+
+	HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
+
+	Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
+
+	ImageUuid string `json:"imageUuid,omitempty" yaml:"image_uuid,omitempty"`
+
+	InstanceLinks map[string]interface{} `json:"instanceLinks,omitempty" yaml:"instance_links,omitempty"`
+
+	InstanceTriggeredStop string `json:"instanceTriggeredStop,omitempty" yaml:"instance_triggered_stop,omitempty"`
+
+	IoMaximumBandwidth int64 `json:"ioMaximumBandwidth,omitempty" yaml:"io_maximum_bandwidth,omitempty"`
+
+	IoMaximumIOps int64 `json:"ioMaximumIOps,omitempty" yaml:"io_maximum_iops,omitempty"`
+
+	Ip string `json:"ip,omitempty" yaml:"ip,omitempty"`
+
+	Ip6 string `json:"ip6,omitempty" yaml:"ip6,omitempty"`
+
+	IpcMode string `json:"ipcMode,omitempty" yaml:"ipc_mode,omitempty"`
+
+	Isolation string `json:"isolation,omitempty" yaml:"isolation,omitempty"`
+
+	KernelMemory int64 `json:"kernelMemory,omitempty" yaml:"kernel_memory,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Labels map[string]interface{} `json:"labels,omitempty" yaml:"labels,omitempty"`
+
+	LogConfig *LogConfig `json:"logConfig,omitempty" yaml:"log_config,omitempty"`
+
+	LxcConf map[string]interface{} `json:"lxcConf,omitempty" yaml:"lxc_conf,omitempty"`
+
+	Memory int64 `json:"memory,omitempty" yaml:"memory,omitempty"`
+
+	MemoryReservation int64 `json:"memoryReservation,omitempty" yaml:"memory_reservation,omitempty"`
+
+	MemorySwap int64 `json:"memorySwap,omitempty" yaml:"memory_swap,omitempty"`
+
+	MemorySwappiness int64 `json:"memorySwappiness,omitempty" yaml:"memory_swappiness,omitempty"`
+
+	MilliCpuReservation int64 `json:"milliCpuReservation,omitempty" yaml:"milli_cpu_reservation,omitempty"`
+
+	Mounts []MountEntry `json:"mounts,omitempty" yaml:"mounts,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	NativeContainer bool `json:"nativeContainer,omitempty" yaml:"native_container,omitempty"`
+
+	NetAlias []string `json:"netAlias,omitempty" yaml:"net_alias,omitempty"`
+
+	NetworkContainerId string `json:"networkContainerId,omitempty" yaml:"network_container_id,omitempty"`
+
+	NetworkIds []string `json:"networkIds,omitempty" yaml:"network_ids,omitempty"`
+
+	NetworkMode string `json:"networkMode,omitempty" yaml:"network_mode,omitempty"`
+
+	OomKillDisable bool `json:"oomKillDisable,omitempty" yaml:"oom_kill_disable,omitempty"`
+
+	OomScoreAdj int64 `json:"oomScoreAdj,omitempty" yaml:"oom_score_adj,omitempty"`
+
+	PidMode string `json:"pidMode,omitempty" yaml:"pid_mode,omitempty"`
+
+	PidsLimit int64 `json:"pidsLimit,omitempty" yaml:"pids_limit,omitempty"`
+
+	Ports []string `json:"ports,omitempty" yaml:"ports,omitempty"`
+
+	PrimaryIpAddress string `json:"primaryIpAddress,omitempty" yaml:"primary_ip_address,omitempty"`
+
+	PrimaryNetworkId string `json:"primaryNetworkId,omitempty" yaml:"primary_network_id,omitempty"`
+
+	Privileged bool `json:"privileged,omitempty" yaml:"privileged,omitempty"`
+
+	PublishAllPorts bool `json:"publishAllPorts,omitempty" yaml:"publish_all_ports,omitempty"`
+
+	ReadOnly bool `json:"readOnly,omitempty" yaml:"read_only,omitempty"`
+
+	RegistryCredentialId string `json:"registryCredentialId,omitempty" yaml:"registry_credential_id,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	RequestedHostId string `json:"requestedHostId,omitempty" yaml:"requested_host_id,omitempty"`
+
+	RestartPolicy *RestartPolicy `json:"restartPolicy,omitempty" yaml:"restart_policy,omitempty"`
+
+	RunInit bool `json:"runInit,omitempty" yaml:"run_init,omitempty"`
+
+	Secrets []SecretReference `json:"secrets,omitempty" yaml:"secrets,omitempty"`
+
+	SecurityOpt []string `json:"securityOpt,omitempty" yaml:"security_opt,omitempty"`
+
+	ServiceId string `json:"serviceId,omitempty" yaml:"service_id,omitempty"`
+
+	ServiceIds []string `json:"serviceIds,omitempty" yaml:"service_ids,omitempty"`
+
+	ShmSize int64 `json:"shmSize,omitempty" yaml:"shm_size,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	StartCount int64 `json:"startCount,omitempty" yaml:"start_count,omitempty"`
+
+	StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	StdinOpen bool `json:"stdinOpen,omitempty" yaml:"stdin_open,omitempty"`
+
+	StopSignal string `json:"stopSignal,omitempty" yaml:"stop_signal,omitempty"`
+
+	StopTimeout int64 `json:"stopTimeout,omitempty" yaml:"stop_timeout,omitempty"`
+
+	StorageOpt map[string]interface{} `json:"storageOpt,omitempty" yaml:"storage_opt,omitempty"`
+
+	Sysctls map[string]interface{} `json:"sysctls,omitempty" yaml:"sysctls,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Tmpfs map[string]interface{} `json:"tmpfs,omitempty" yaml:"tmpfs,omitempty"`
+
+	Token string `json:"token,omitempty" yaml:"token,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Tty bool `json:"tty,omitempty" yaml:"tty,omitempty"`
+
+	Ulimits []Ulimit `json:"ulimits,omitempty" yaml:"ulimits,omitempty"`
+
+	User string `json:"user,omitempty" yaml:"user,omitempty"`
+
+	UserPorts []string `json:"userPorts,omitempty" yaml:"user_ports,omitempty"`
+
+	UsernsMode string `json:"usernsMode,omitempty" yaml:"userns_mode,omitempty"`
+
+	Uts string `json:"uts,omitempty" yaml:"uts,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Version string `json:"version,omitempty" yaml:"version,omitempty"`
+
+	VolumeDriver string `json:"volumeDriver,omitempty" yaml:"volume_driver,omitempty"`
+
+	WorkingDir string `json:"workingDir,omitempty" yaml:"working_dir,omitempty"`
+}
+
+type ContainerCollection struct {
+	Collection
+	Data   []Container `json:"data,omitempty"`
+	client *ContainerClient
+}
+
+type ContainerClient struct {
+	rancherClient *RancherClient
+}
+
+type ContainerOperations interface {
+	List(opts *ListOpts) (*ContainerCollection, error)
+	Create(opts *Container) (*Container, error)
+	Update(existing *Container, updates interface{}) (*Container, error)
+	ById(id string) (*Container, error)
+	Delete(container *Container) error
+
+	ActionAllocate(*Container) (*Instance, error)
+
+	ActionConsole(*Container, *InstanceConsoleInput) (*InstanceConsole, error)
+
+	ActionCreate(*Container) (*Instance, error)
+
+	ActionDeallocate(*Container) (*Instance, error)
+
+	ActionError(*Container) (*Instance, error)
+
+	ActionExecute(*Container, *ContainerExec) (*HostAccess, error)
+
+	ActionLogs(*Container, *ContainerLogs) (*HostAccess, error)
+
+	ActionMigrate(*Container) (*Instance, error)
+
+	ActionProxy(*Container, *ContainerProxy) (*HostAccess, error)
+
+	ActionPurge(*Container) (*Instance, error)
+
+	ActionRemove(*Container) (*Instance, error)
+
+	ActionRestart(*Container) (*Instance, error)
+
+	ActionStart(*Container) (*Instance, error)
+
+	ActionStop(*Container, *InstanceStop) (*Instance, error)
+
+	ActionUpdate(*Container) (*Instance, error)
+
+	ActionUpdatehealthy(*Container) (*Instance, error)
+
+	ActionUpdatereinitializing(*Container) (*Instance, error)
+
+	ActionUpdateunhealthy(*Container) (*Instance, error)
+}
+
+func newContainerClient(rancherClient *RancherClient) *ContainerClient {
+	return &ContainerClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ContainerClient) Create(container *Container) (*Container, error) {
+	resp := &Container{}
+	err := c.rancherClient.doCreate(CONTAINER_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ContainerClient) Update(existing *Container, updates interface{}) (*Container, error) {
+	resp := &Container{}
+	err := c.rancherClient.doUpdate(CONTAINER_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ContainerClient) List(opts *ListOpts) (*ContainerCollection, error) {
+	resp := &ContainerCollection{}
+	err := c.rancherClient.doList(CONTAINER_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ContainerCollection) Next() (*ContainerCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ContainerCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ContainerClient) ById(id string) (*Container, error) {
+	resp := &Container{}
+	err := c.rancherClient.doById(CONTAINER_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ContainerClient) Delete(container *Container) error {
+	return c.rancherClient.doResourceDelete(CONTAINER_TYPE, &container.Resource)
+}
+
+func (c *ContainerClient) ActionAllocate(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "allocate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionConsole(resource *Container, input *InstanceConsoleInput) (*InstanceConsole, error) {
+
+	resp := &InstanceConsole{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "console", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionCreate(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionDeallocate(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "deallocate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionError(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionExecute(resource *Container, input *ContainerExec) (*HostAccess, error) {
+
+	resp := &HostAccess{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "execute", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionLogs(resource *Container, input *ContainerLogs) (*HostAccess, error) {
+
+	resp := &HostAccess{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "logs", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionMigrate(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "migrate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionProxy(resource *Container, input *ContainerProxy) (*HostAccess, error) {
+
+	resp := &HostAccess{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "proxy", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionPurge(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionRemove(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionRestart(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "restart", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionStart(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "start", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionStop(resource *Container, input *InstanceStop) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "stop", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionUpdate(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionUpdatehealthy(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "updatehealthy", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionUpdatereinitializing(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "updatereinitializing", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerClient) ActionUpdateunhealthy(resource *Container) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(CONTAINER_TYPE, "updateunhealthy", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_container_event.go

@@ -0,0 +1,129 @@
+package client
+
+const (
+	CONTAINER_EVENT_TYPE = "containerEvent"
+)
+
+type ContainerEvent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DockerInspect interface{} `json:"dockerInspect,omitempty" yaml:"docker_inspect,omitempty"`
+
+	ExternalFrom string `json:"externalFrom,omitempty" yaml:"external_from,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	ExternalStatus string `json:"externalStatus,omitempty" yaml:"external_status,omitempty"`
+
+	ExternalTimestamp int64 `json:"externalTimestamp,omitempty" yaml:"external_timestamp,omitempty"`
+
+	HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ReportedHostUuid string `json:"reportedHostUuid,omitempty" yaml:"reported_host_uuid,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+}
+
+type ContainerEventCollection struct {
+	Collection
+	Data   []ContainerEvent `json:"data,omitempty"`
+	client *ContainerEventClient
+}
+
+type ContainerEventClient struct {
+	rancherClient *RancherClient
+}
+
+type ContainerEventOperations interface {
+	List(opts *ListOpts) (*ContainerEventCollection, error)
+	Create(opts *ContainerEvent) (*ContainerEvent, error)
+	Update(existing *ContainerEvent, updates interface{}) (*ContainerEvent, error)
+	ById(id string) (*ContainerEvent, error)
+	Delete(container *ContainerEvent) error
+
+	ActionCreate(*ContainerEvent) (*ContainerEvent, error)
+
+	ActionRemove(*ContainerEvent) (*ContainerEvent, error)
+}
+
+func newContainerEventClient(rancherClient *RancherClient) *ContainerEventClient {
+	return &ContainerEventClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ContainerEventClient) Create(container *ContainerEvent) (*ContainerEvent, error) {
+	resp := &ContainerEvent{}
+	err := c.rancherClient.doCreate(CONTAINER_EVENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ContainerEventClient) Update(existing *ContainerEvent, updates interface{}) (*ContainerEvent, error) {
+	resp := &ContainerEvent{}
+	err := c.rancherClient.doUpdate(CONTAINER_EVENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ContainerEventClient) List(opts *ListOpts) (*ContainerEventCollection, error) {
+	resp := &ContainerEventCollection{}
+	err := c.rancherClient.doList(CONTAINER_EVENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ContainerEventCollection) Next() (*ContainerEventCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ContainerEventCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ContainerEventClient) ById(id string) (*ContainerEvent, error) {
+	resp := &ContainerEvent{}
+	err := c.rancherClient.doById(CONTAINER_EVENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ContainerEventClient) Delete(container *ContainerEvent) error {
+	return c.rancherClient.doResourceDelete(CONTAINER_EVENT_TYPE, &container.Resource)
+}
+
+func (c *ContainerEventClient) ActionCreate(resource *ContainerEvent) (*ContainerEvent, error) {
+
+	resp := &ContainerEvent{}
+
+	err := c.rancherClient.doAction(CONTAINER_EVENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ContainerEventClient) ActionRemove(resource *ContainerEvent) (*ContainerEvent, error) {
+
+	resp := &ContainerEvent{}
+
+	err := c.rancherClient.doAction(CONTAINER_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_container_exec.go

@@ -0,0 +1,85 @@
+package client
+
+const (
+	CONTAINER_EXEC_TYPE = "containerExec"
+)
+
+type ContainerExec struct {
+	Resource
+
+	AttachStdin bool `json:"attachStdin,omitempty" yaml:"attach_stdin,omitempty"`
+
+	AttachStdout bool `json:"attachStdout,omitempty" yaml:"attach_stdout,omitempty"`
+
+	Command []string `json:"command,omitempty" yaml:"command,omitempty"`
+
+	Tty bool `json:"tty,omitempty" yaml:"tty,omitempty"`
+}
+
+type ContainerExecCollection struct {
+	Collection
+	Data   []ContainerExec `json:"data,omitempty"`
+	client *ContainerExecClient
+}
+
+type ContainerExecClient struct {
+	rancherClient *RancherClient
+}
+
+type ContainerExecOperations interface {
+	List(opts *ListOpts) (*ContainerExecCollection, error)
+	Create(opts *ContainerExec) (*ContainerExec, error)
+	Update(existing *ContainerExec, updates interface{}) (*ContainerExec, error)
+	ById(id string) (*ContainerExec, error)
+	Delete(container *ContainerExec) error
+}
+
+func newContainerExecClient(rancherClient *RancherClient) *ContainerExecClient {
+	return &ContainerExecClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ContainerExecClient) Create(container *ContainerExec) (*ContainerExec, error) {
+	resp := &ContainerExec{}
+	err := c.rancherClient.doCreate(CONTAINER_EXEC_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ContainerExecClient) Update(existing *ContainerExec, updates interface{}) (*ContainerExec, error) {
+	resp := &ContainerExec{}
+	err := c.rancherClient.doUpdate(CONTAINER_EXEC_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ContainerExecClient) List(opts *ListOpts) (*ContainerExecCollection, error) {
+	resp := &ContainerExecCollection{}
+	err := c.rancherClient.doList(CONTAINER_EXEC_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ContainerExecCollection) Next() (*ContainerExecCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ContainerExecCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ContainerExecClient) ById(id string) (*ContainerExec, error) {
+	resp := &ContainerExec{}
+	err := c.rancherClient.doById(CONTAINER_EXEC_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ContainerExecClient) Delete(container *ContainerExec) error {
+	return c.rancherClient.doResourceDelete(CONTAINER_EXEC_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_container_logs.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	CONTAINER_LOGS_TYPE = "containerLogs"
+)
+
+type ContainerLogs struct {
+	Resource
+
+	Follow bool `json:"follow,omitempty" yaml:"follow,omitempty"`
+
+	Lines int64 `json:"lines,omitempty" yaml:"lines,omitempty"`
+}
+
+type ContainerLogsCollection struct {
+	Collection
+	Data   []ContainerLogs `json:"data,omitempty"`
+	client *ContainerLogsClient
+}
+
+type ContainerLogsClient struct {
+	rancherClient *RancherClient
+}
+
+type ContainerLogsOperations interface {
+	List(opts *ListOpts) (*ContainerLogsCollection, error)
+	Create(opts *ContainerLogs) (*ContainerLogs, error)
+	Update(existing *ContainerLogs, updates interface{}) (*ContainerLogs, error)
+	ById(id string) (*ContainerLogs, error)
+	Delete(container *ContainerLogs) error
+}
+
+func newContainerLogsClient(rancherClient *RancherClient) *ContainerLogsClient {
+	return &ContainerLogsClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ContainerLogsClient) Create(container *ContainerLogs) (*ContainerLogs, error) {
+	resp := &ContainerLogs{}
+	err := c.rancherClient.doCreate(CONTAINER_LOGS_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ContainerLogsClient) Update(existing *ContainerLogs, updates interface{}) (*ContainerLogs, error) {
+	resp := &ContainerLogs{}
+	err := c.rancherClient.doUpdate(CONTAINER_LOGS_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ContainerLogsClient) List(opts *ListOpts) (*ContainerLogsCollection, error) {
+	resp := &ContainerLogsCollection{}
+	err := c.rancherClient.doList(CONTAINER_LOGS_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ContainerLogsCollection) Next() (*ContainerLogsCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ContainerLogsCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ContainerLogsClient) ById(id string) (*ContainerLogs, error) {
+	resp := &ContainerLogs{}
+	err := c.rancherClient.doById(CONTAINER_LOGS_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ContainerLogsClient) Delete(container *ContainerLogs) error {
+	return c.rancherClient.doResourceDelete(CONTAINER_LOGS_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_container_proxy.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	CONTAINER_PROXY_TYPE = "containerProxy"
+)
+
+type ContainerProxy struct {
+	Resource
+
+	Port int64 `json:"port,omitempty" yaml:"port,omitempty"`
+
+	Scheme string `json:"scheme,omitempty" yaml:"scheme,omitempty"`
+}
+
+type ContainerProxyCollection struct {
+	Collection
+	Data   []ContainerProxy `json:"data,omitempty"`
+	client *ContainerProxyClient
+}
+
+type ContainerProxyClient struct {
+	rancherClient *RancherClient
+}
+
+type ContainerProxyOperations interface {
+	List(opts *ListOpts) (*ContainerProxyCollection, error)
+	Create(opts *ContainerProxy) (*ContainerProxy, error)
+	Update(existing *ContainerProxy, updates interface{}) (*ContainerProxy, error)
+	ById(id string) (*ContainerProxy, error)
+	Delete(container *ContainerProxy) error
+}
+
+func newContainerProxyClient(rancherClient *RancherClient) *ContainerProxyClient {
+	return &ContainerProxyClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ContainerProxyClient) Create(container *ContainerProxy) (*ContainerProxy, error) {
+	resp := &ContainerProxy{}
+	err := c.rancherClient.doCreate(CONTAINER_PROXY_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ContainerProxyClient) Update(existing *ContainerProxy, updates interface{}) (*ContainerProxy, error) {
+	resp := &ContainerProxy{}
+	err := c.rancherClient.doUpdate(CONTAINER_PROXY_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ContainerProxyClient) List(opts *ListOpts) (*ContainerProxyCollection, error) {
+	resp := &ContainerProxyCollection{}
+	err := c.rancherClient.doList(CONTAINER_PROXY_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ContainerProxyCollection) Next() (*ContainerProxyCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ContainerProxyCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ContainerProxyClient) ById(id string) (*ContainerProxy, error) {
+	resp := &ContainerProxy{}
+	err := c.rancherClient.doById(CONTAINER_PROXY_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ContainerProxyClient) Delete(container *ContainerProxy) error {
+	return c.rancherClient.doResourceDelete(CONTAINER_PROXY_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_credential.go

@@ -0,0 +1,173 @@
+package client
+
+const (
+	CREDENTIAL_TYPE = "credential"
+)
+
+type Credential struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PublicValue string `json:"publicValue,omitempty" yaml:"public_value,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	SecretValue string `json:"secretValue,omitempty" yaml:"secret_value,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type CredentialCollection struct {
+	Collection
+	Data   []Credential `json:"data,omitempty"`
+	client *CredentialClient
+}
+
+type CredentialClient struct {
+	rancherClient *RancherClient
+}
+
+type CredentialOperations interface {
+	List(opts *ListOpts) (*CredentialCollection, error)
+	Create(opts *Credential) (*Credential, error)
+	Update(existing *Credential, updates interface{}) (*Credential, error)
+	ById(id string) (*Credential, error)
+	Delete(container *Credential) error
+
+	ActionActivate(*Credential) (*Credential, error)
+
+	ActionCreate(*Credential) (*Credential, error)
+
+	ActionDeactivate(*Credential) (*Credential, error)
+
+	ActionPurge(*Credential) (*Credential, error)
+
+	ActionRemove(*Credential) (*Credential, error)
+
+	ActionUpdate(*Credential) (*Credential, error)
+}
+
+func newCredentialClient(rancherClient *RancherClient) *CredentialClient {
+	return &CredentialClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *CredentialClient) Create(container *Credential) (*Credential, error) {
+	resp := &Credential{}
+	err := c.rancherClient.doCreate(CREDENTIAL_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *CredentialClient) Update(existing *Credential, updates interface{}) (*Credential, error) {
+	resp := &Credential{}
+	err := c.rancherClient.doUpdate(CREDENTIAL_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *CredentialClient) List(opts *ListOpts) (*CredentialCollection, error) {
+	resp := &CredentialCollection{}
+	err := c.rancherClient.doList(CREDENTIAL_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *CredentialCollection) Next() (*CredentialCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &CredentialCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *CredentialClient) ById(id string) (*Credential, error) {
+	resp := &Credential{}
+	err := c.rancherClient.doById(CREDENTIAL_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *CredentialClient) Delete(container *Credential) error {
+	return c.rancherClient.doResourceDelete(CREDENTIAL_TYPE, &container.Resource)
+}
+
+func (c *CredentialClient) ActionActivate(resource *Credential) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(CREDENTIAL_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *CredentialClient) ActionCreate(resource *Credential) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(CREDENTIAL_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *CredentialClient) ActionDeactivate(resource *Credential) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(CREDENTIAL_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *CredentialClient) ActionPurge(resource *Credential) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(CREDENTIAL_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *CredentialClient) ActionRemove(resource *Credential) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(CREDENTIAL_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *CredentialClient) ActionUpdate(resource *Credential) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(CREDENTIAL_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_databasechangelog.go

@@ -0,0 +1,97 @@
+package client
+
+const (
+	DATABASECHANGELOG_TYPE = "databasechangelog"
+)
+
+type Databasechangelog struct {
+	Resource
+
+	Author string `json:"author,omitempty" yaml:"author,omitempty"`
+
+	Comments string `json:"comments,omitempty" yaml:"comments,omitempty"`
+
+	Dateexecuted string `json:"dateexecuted,omitempty" yaml:"dateexecuted,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Exectype string `json:"exectype,omitempty" yaml:"exectype,omitempty"`
+
+	Filename string `json:"filename,omitempty" yaml:"filename,omitempty"`
+
+	Liquibase string `json:"liquibase,omitempty" yaml:"liquibase,omitempty"`
+
+	Md5sum string `json:"md5sum,omitempty" yaml:"md5sum,omitempty"`
+
+	Orderexecuted int64 `json:"orderexecuted,omitempty" yaml:"orderexecuted,omitempty"`
+
+	Tag string `json:"tag,omitempty" yaml:"tag,omitempty"`
+}
+
+type DatabasechangelogCollection struct {
+	Collection
+	Data   []Databasechangelog `json:"data,omitempty"`
+	client *DatabasechangelogClient
+}
+
+type DatabasechangelogClient struct {
+	rancherClient *RancherClient
+}
+
+type DatabasechangelogOperations interface {
+	List(opts *ListOpts) (*DatabasechangelogCollection, error)
+	Create(opts *Databasechangelog) (*Databasechangelog, error)
+	Update(existing *Databasechangelog, updates interface{}) (*Databasechangelog, error)
+	ById(id string) (*Databasechangelog, error)
+	Delete(container *Databasechangelog) error
+}
+
+func newDatabasechangelogClient(rancherClient *RancherClient) *DatabasechangelogClient {
+	return &DatabasechangelogClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *DatabasechangelogClient) Create(container *Databasechangelog) (*Databasechangelog, error) {
+	resp := &Databasechangelog{}
+	err := c.rancherClient.doCreate(DATABASECHANGELOG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *DatabasechangelogClient) Update(existing *Databasechangelog, updates interface{}) (*Databasechangelog, error) {
+	resp := &Databasechangelog{}
+	err := c.rancherClient.doUpdate(DATABASECHANGELOG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *DatabasechangelogClient) List(opts *ListOpts) (*DatabasechangelogCollection, error) {
+	resp := &DatabasechangelogCollection{}
+	err := c.rancherClient.doList(DATABASECHANGELOG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *DatabasechangelogCollection) Next() (*DatabasechangelogCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &DatabasechangelogCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *DatabasechangelogClient) ById(id string) (*Databasechangelog, error) {
+	resp := &Databasechangelog{}
+	err := c.rancherClient.doById(DATABASECHANGELOG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *DatabasechangelogClient) Delete(container *Databasechangelog) error {
+	return c.rancherClient.doResourceDelete(DATABASECHANGELOG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_databasechangeloglock.go

@@ -0,0 +1,83 @@
+package client
+
+const (
+	DATABASECHANGELOGLOCK_TYPE = "databasechangeloglock"
+)
+
+type Databasechangeloglock struct {
+	Resource
+
+	Locked bool `json:"locked,omitempty" yaml:"locked,omitempty"`
+
+	Lockedby string `json:"lockedby,omitempty" yaml:"lockedby,omitempty"`
+
+	Lockgranted string `json:"lockgranted,omitempty" yaml:"lockgranted,omitempty"`
+}
+
+type DatabasechangeloglockCollection struct {
+	Collection
+	Data   []Databasechangeloglock `json:"data,omitempty"`
+	client *DatabasechangeloglockClient
+}
+
+type DatabasechangeloglockClient struct {
+	rancherClient *RancherClient
+}
+
+type DatabasechangeloglockOperations interface {
+	List(opts *ListOpts) (*DatabasechangeloglockCollection, error)
+	Create(opts *Databasechangeloglock) (*Databasechangeloglock, error)
+	Update(existing *Databasechangeloglock, updates interface{}) (*Databasechangeloglock, error)
+	ById(id string) (*Databasechangeloglock, error)
+	Delete(container *Databasechangeloglock) error
+}
+
+func newDatabasechangeloglockClient(rancherClient *RancherClient) *DatabasechangeloglockClient {
+	return &DatabasechangeloglockClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *DatabasechangeloglockClient) Create(container *Databasechangeloglock) (*Databasechangeloglock, error) {
+	resp := &Databasechangeloglock{}
+	err := c.rancherClient.doCreate(DATABASECHANGELOGLOCK_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *DatabasechangeloglockClient) Update(existing *Databasechangeloglock, updates interface{}) (*Databasechangeloglock, error) {
+	resp := &Databasechangeloglock{}
+	err := c.rancherClient.doUpdate(DATABASECHANGELOGLOCK_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *DatabasechangeloglockClient) List(opts *ListOpts) (*DatabasechangeloglockCollection, error) {
+	resp := &DatabasechangeloglockCollection{}
+	err := c.rancherClient.doList(DATABASECHANGELOGLOCK_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *DatabasechangeloglockCollection) Next() (*DatabasechangeloglockCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &DatabasechangeloglockCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *DatabasechangeloglockClient) ById(id string) (*Databasechangeloglock, error) {
+	resp := &Databasechangeloglock{}
+	err := c.rancherClient.doById(DATABASECHANGELOGLOCK_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *DatabasechangeloglockClient) Delete(container *Databasechangeloglock) error {
+	return c.rancherClient.doResourceDelete(DATABASECHANGELOGLOCK_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_default_network.go

@@ -0,0 +1,183 @@
+package client
+
+const (
+	DEFAULT_NETWORK_TYPE = "defaultNetwork"
+)
+
+type DefaultNetwork struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DefaultPolicyAction string `json:"defaultPolicyAction,omitempty" yaml:"default_policy_action,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Dns []string `json:"dns,omitempty" yaml:"dns,omitempty"`
+
+	DnsSearch []string `json:"dnsSearch,omitempty" yaml:"dns_search,omitempty"`
+
+	HostPorts bool `json:"hostPorts,omitempty" yaml:"host_ports,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Policy []NetworkPolicyRule `json:"policy,omitempty" yaml:"policy,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Subnets []Subnet `json:"subnets,omitempty" yaml:"subnets,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type DefaultNetworkCollection struct {
+	Collection
+	Data   []DefaultNetwork `json:"data,omitempty"`
+	client *DefaultNetworkClient
+}
+
+type DefaultNetworkClient struct {
+	rancherClient *RancherClient
+}
+
+type DefaultNetworkOperations interface {
+	List(opts *ListOpts) (*DefaultNetworkCollection, error)
+	Create(opts *DefaultNetwork) (*DefaultNetwork, error)
+	Update(existing *DefaultNetwork, updates interface{}) (*DefaultNetwork, error)
+	ById(id string) (*DefaultNetwork, error)
+	Delete(container *DefaultNetwork) error
+
+	ActionActivate(*DefaultNetwork) (*Network, error)
+
+	ActionCreate(*DefaultNetwork) (*Network, error)
+
+	ActionDeactivate(*DefaultNetwork) (*Network, error)
+
+	ActionPurge(*DefaultNetwork) (*Network, error)
+
+	ActionRemove(*DefaultNetwork) (*Network, error)
+
+	ActionUpdate(*DefaultNetwork) (*Network, error)
+}
+
+func newDefaultNetworkClient(rancherClient *RancherClient) *DefaultNetworkClient {
+	return &DefaultNetworkClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *DefaultNetworkClient) Create(container *DefaultNetwork) (*DefaultNetwork, error) {
+	resp := &DefaultNetwork{}
+	err := c.rancherClient.doCreate(DEFAULT_NETWORK_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) Update(existing *DefaultNetwork, updates interface{}) (*DefaultNetwork, error) {
+	resp := &DefaultNetwork{}
+	err := c.rancherClient.doUpdate(DEFAULT_NETWORK_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) List(opts *ListOpts) (*DefaultNetworkCollection, error) {
+	resp := &DefaultNetworkCollection{}
+	err := c.rancherClient.doList(DEFAULT_NETWORK_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *DefaultNetworkCollection) Next() (*DefaultNetworkCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &DefaultNetworkCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *DefaultNetworkClient) ById(id string) (*DefaultNetwork, error) {
+	resp := &DefaultNetwork{}
+	err := c.rancherClient.doById(DEFAULT_NETWORK_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) Delete(container *DefaultNetwork) error {
+	return c.rancherClient.doResourceDelete(DEFAULT_NETWORK_TYPE, &container.Resource)
+}
+
+func (c *DefaultNetworkClient) ActionActivate(resource *DefaultNetwork) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(DEFAULT_NETWORK_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) ActionCreate(resource *DefaultNetwork) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(DEFAULT_NETWORK_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) ActionDeactivate(resource *DefaultNetwork) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(DEFAULT_NETWORK_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) ActionPurge(resource *DefaultNetwork) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(DEFAULT_NETWORK_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) ActionRemove(resource *DefaultNetwork) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(DEFAULT_NETWORK_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DefaultNetworkClient) ActionUpdate(resource *DefaultNetwork) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(DEFAULT_NETWORK_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_digitalocean_config.go

@@ -0,0 +1,101 @@
+package client
+
+const (
+	DIGITALOCEAN_CONFIG_TYPE = "digitaloceanConfig"
+)
+
+type DigitaloceanConfig struct {
+	Resource
+
+	AccessToken string `json:"accessToken,omitempty" yaml:"access_token,omitempty"`
+
+	Backups bool `json:"backups,omitempty" yaml:"backups,omitempty"`
+
+	Image string `json:"image,omitempty" yaml:"image,omitempty"`
+
+	Ipv6 bool `json:"ipv6,omitempty" yaml:"ipv6,omitempty"`
+
+	PrivateNetworking bool `json:"privateNetworking,omitempty" yaml:"private_networking,omitempty"`
+
+	Region string `json:"region,omitempty" yaml:"region,omitempty"`
+
+	Size string `json:"size,omitempty" yaml:"size,omitempty"`
+
+	SshKeyFingerprint string `json:"sshKeyFingerprint,omitempty" yaml:"ssh_key_fingerprint,omitempty"`
+
+	SshKeyPath string `json:"sshKeyPath,omitempty" yaml:"ssh_key_path,omitempty"`
+
+	SshPort string `json:"sshPort,omitempty" yaml:"ssh_port,omitempty"`
+
+	SshUser string `json:"sshUser,omitempty" yaml:"ssh_user,omitempty"`
+
+	Userdata string `json:"userdata,omitempty" yaml:"userdata,omitempty"`
+}
+
+type DigitaloceanConfigCollection struct {
+	Collection
+	Data   []DigitaloceanConfig `json:"data,omitempty"`
+	client *DigitaloceanConfigClient
+}
+
+type DigitaloceanConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type DigitaloceanConfigOperations interface {
+	List(opts *ListOpts) (*DigitaloceanConfigCollection, error)
+	Create(opts *DigitaloceanConfig) (*DigitaloceanConfig, error)
+	Update(existing *DigitaloceanConfig, updates interface{}) (*DigitaloceanConfig, error)
+	ById(id string) (*DigitaloceanConfig, error)
+	Delete(container *DigitaloceanConfig) error
+}
+
+func newDigitaloceanConfigClient(rancherClient *RancherClient) *DigitaloceanConfigClient {
+	return &DigitaloceanConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *DigitaloceanConfigClient) Create(container *DigitaloceanConfig) (*DigitaloceanConfig, error) {
+	resp := &DigitaloceanConfig{}
+	err := c.rancherClient.doCreate(DIGITALOCEAN_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *DigitaloceanConfigClient) Update(existing *DigitaloceanConfig, updates interface{}) (*DigitaloceanConfig, error) {
+	resp := &DigitaloceanConfig{}
+	err := c.rancherClient.doUpdate(DIGITALOCEAN_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *DigitaloceanConfigClient) List(opts *ListOpts) (*DigitaloceanConfigCollection, error) {
+	resp := &DigitaloceanConfigCollection{}
+	err := c.rancherClient.doList(DIGITALOCEAN_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *DigitaloceanConfigCollection) Next() (*DigitaloceanConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &DigitaloceanConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *DigitaloceanConfigClient) ById(id string) (*DigitaloceanConfig, error) {
+	resp := &DigitaloceanConfig{}
+	err := c.rancherClient.doById(DIGITALOCEAN_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *DigitaloceanConfigClient) Delete(container *DigitaloceanConfig) error {
+	return c.rancherClient.doResourceDelete(DIGITALOCEAN_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_dns_service.go

@@ -0,0 +1,285 @@
+package client
+
+const (
+	DNS_SERVICE_TYPE = "dnsService"
+)
+
+type DnsService struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AssignServiceIpAddress bool `json:"assignServiceIpAddress,omitempty" yaml:"assign_service_ip_address,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	InstanceIds []string `json:"instanceIds,omitempty" yaml:"instance_ids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
+
+	LinkedServices map[string]interface{} `json:"linkedServices,omitempty" yaml:"linked_services,omitempty"`
+
+	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	RetainIp bool `json:"retainIp,omitempty" yaml:"retain_ip,omitempty"`
+
+	SelectorLink string `json:"selectorLink,omitempty" yaml:"selector_link,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Upgrade *ServiceUpgrade `json:"upgrade,omitempty" yaml:"upgrade,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type DnsServiceCollection struct {
+	Collection
+	Data   []DnsService `json:"data,omitempty"`
+	client *DnsServiceClient
+}
+
+type DnsServiceClient struct {
+	rancherClient *RancherClient
+}
+
+type DnsServiceOperations interface {
+	List(opts *ListOpts) (*DnsServiceCollection, error)
+	Create(opts *DnsService) (*DnsService, error)
+	Update(existing *DnsService, updates interface{}) (*DnsService, error)
+	ById(id string) (*DnsService, error)
+	Delete(container *DnsService) error
+
+	ActionActivate(*DnsService) (*Service, error)
+
+	ActionAddservicelink(*DnsService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionCancelupgrade(*DnsService) (*Service, error)
+
+	ActionContinueupgrade(*DnsService) (*Service, error)
+
+	ActionCreate(*DnsService) (*Service, error)
+
+	ActionDeactivate(*DnsService) (*Service, error)
+
+	ActionFinishupgrade(*DnsService) (*Service, error)
+
+	ActionRemove(*DnsService) (*Service, error)
+
+	ActionRemoveservicelink(*DnsService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionRestart(*DnsService, *ServiceRestart) (*Service, error)
+
+	ActionRollback(*DnsService) (*Service, error)
+
+	ActionSetservicelinks(*DnsService, *SetServiceLinksInput) (*Service, error)
+
+	ActionUpdate(*DnsService) (*Service, error)
+
+	ActionUpgrade(*DnsService, *ServiceUpgrade) (*Service, error)
+}
+
+func newDnsServiceClient(rancherClient *RancherClient) *DnsServiceClient {
+	return &DnsServiceClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *DnsServiceClient) Create(container *DnsService) (*DnsService, error) {
+	resp := &DnsService{}
+	err := c.rancherClient.doCreate(DNS_SERVICE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *DnsServiceClient) Update(existing *DnsService, updates interface{}) (*DnsService, error) {
+	resp := &DnsService{}
+	err := c.rancherClient.doUpdate(DNS_SERVICE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *DnsServiceClient) List(opts *ListOpts) (*DnsServiceCollection, error) {
+	resp := &DnsServiceCollection{}
+	err := c.rancherClient.doList(DNS_SERVICE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *DnsServiceCollection) Next() (*DnsServiceCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &DnsServiceCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *DnsServiceClient) ById(id string) (*DnsService, error) {
+	resp := &DnsService{}
+	err := c.rancherClient.doById(DNS_SERVICE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *DnsServiceClient) Delete(container *DnsService) error {
+	return c.rancherClient.doResourceDelete(DNS_SERVICE_TYPE, &container.Resource)
+}
+
+func (c *DnsServiceClient) ActionActivate(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionAddservicelink(resource *DnsService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "addservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionCancelupgrade(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionContinueupgrade(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "continueupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionCreate(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionDeactivate(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionFinishupgrade(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionRemove(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionRemoveservicelink(resource *DnsService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "removeservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionRestart(resource *DnsService, input *ServiceRestart) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionRollback(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionSetservicelinks(resource *DnsService, input *SetServiceLinksInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "setservicelinks", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionUpdate(resource *DnsService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *DnsServiceClient) ActionUpgrade(resource *DnsService, input *ServiceUpgrade) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_docker_build.go

@@ -0,0 +1,89 @@
+package client
+
+const (
+	DOCKER_BUILD_TYPE = "dockerBuild"
+)
+
+type DockerBuild struct {
+	Resource
+
+	Context string `json:"context,omitempty" yaml:"context,omitempty"`
+
+	Dockerfile string `json:"dockerfile,omitempty" yaml:"dockerfile,omitempty"`
+
+	Forcerm bool `json:"forcerm,omitempty" yaml:"forcerm,omitempty"`
+
+	Nocache bool `json:"nocache,omitempty" yaml:"nocache,omitempty"`
+
+	Remote string `json:"remote,omitempty" yaml:"remote,omitempty"`
+
+	Rm bool `json:"rm,omitempty" yaml:"rm,omitempty"`
+}
+
+type DockerBuildCollection struct {
+	Collection
+	Data   []DockerBuild `json:"data,omitempty"`
+	client *DockerBuildClient
+}
+
+type DockerBuildClient struct {
+	rancherClient *RancherClient
+}
+
+type DockerBuildOperations interface {
+	List(opts *ListOpts) (*DockerBuildCollection, error)
+	Create(opts *DockerBuild) (*DockerBuild, error)
+	Update(existing *DockerBuild, updates interface{}) (*DockerBuild, error)
+	ById(id string) (*DockerBuild, error)
+	Delete(container *DockerBuild) error
+}
+
+func newDockerBuildClient(rancherClient *RancherClient) *DockerBuildClient {
+	return &DockerBuildClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *DockerBuildClient) Create(container *DockerBuild) (*DockerBuild, error) {
+	resp := &DockerBuild{}
+	err := c.rancherClient.doCreate(DOCKER_BUILD_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *DockerBuildClient) Update(existing *DockerBuild, updates interface{}) (*DockerBuild, error) {
+	resp := &DockerBuild{}
+	err := c.rancherClient.doUpdate(DOCKER_BUILD_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *DockerBuildClient) List(opts *ListOpts) (*DockerBuildCollection, error) {
+	resp := &DockerBuildCollection{}
+	err := c.rancherClient.doList(DOCKER_BUILD_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *DockerBuildCollection) Next() (*DockerBuildCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &DockerBuildCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *DockerBuildClient) ById(id string) (*DockerBuild, error) {
+	resp := &DockerBuild{}
+	err := c.rancherClient.doById(DOCKER_BUILD_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *DockerBuildClient) Delete(container *DockerBuild) error {
+	return c.rancherClient.doResourceDelete(DOCKER_BUILD_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_extension_implementation.go

@@ -0,0 +1,83 @@
+package client
+
+const (
+	EXTENSION_IMPLEMENTATION_TYPE = "extensionImplementation"
+)
+
+type ExtensionImplementation struct {
+	Resource
+
+	ClassName string `json:"className,omitempty" yaml:"class_name,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Properties map[string]interface{} `json:"properties,omitempty" yaml:"properties,omitempty"`
+}
+
+type ExtensionImplementationCollection struct {
+	Collection
+	Data   []ExtensionImplementation `json:"data,omitempty"`
+	client *ExtensionImplementationClient
+}
+
+type ExtensionImplementationClient struct {
+	rancherClient *RancherClient
+}
+
+type ExtensionImplementationOperations interface {
+	List(opts *ListOpts) (*ExtensionImplementationCollection, error)
+	Create(opts *ExtensionImplementation) (*ExtensionImplementation, error)
+	Update(existing *ExtensionImplementation, updates interface{}) (*ExtensionImplementation, error)
+	ById(id string) (*ExtensionImplementation, error)
+	Delete(container *ExtensionImplementation) error
+}
+
+func newExtensionImplementationClient(rancherClient *RancherClient) *ExtensionImplementationClient {
+	return &ExtensionImplementationClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExtensionImplementationClient) Create(container *ExtensionImplementation) (*ExtensionImplementation, error) {
+	resp := &ExtensionImplementation{}
+	err := c.rancherClient.doCreate(EXTENSION_IMPLEMENTATION_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExtensionImplementationClient) Update(existing *ExtensionImplementation, updates interface{}) (*ExtensionImplementation, error) {
+	resp := &ExtensionImplementation{}
+	err := c.rancherClient.doUpdate(EXTENSION_IMPLEMENTATION_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExtensionImplementationClient) List(opts *ListOpts) (*ExtensionImplementationCollection, error) {
+	resp := &ExtensionImplementationCollection{}
+	err := c.rancherClient.doList(EXTENSION_IMPLEMENTATION_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExtensionImplementationCollection) Next() (*ExtensionImplementationCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExtensionImplementationCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExtensionImplementationClient) ById(id string) (*ExtensionImplementation, error) {
+	resp := &ExtensionImplementation{}
+	err := c.rancherClient.doById(EXTENSION_IMPLEMENTATION_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExtensionImplementationClient) Delete(container *ExtensionImplementation) error {
+	return c.rancherClient.doResourceDelete(EXTENSION_IMPLEMENTATION_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_extension_point.go

@@ -0,0 +1,87 @@
+package client
+
+const (
+	EXTENSION_POINT_TYPE = "extensionPoint"
+)
+
+type ExtensionPoint struct {
+	Resource
+
+	ExcludeSetting string `json:"excludeSetting,omitempty" yaml:"exclude_setting,omitempty"`
+
+	Implementations []ExtensionImplementation `json:"implementations,omitempty" yaml:"implementations,omitempty"`
+
+	IncludeSetting string `json:"includeSetting,omitempty" yaml:"include_setting,omitempty"`
+
+	ListSetting string `json:"listSetting,omitempty" yaml:"list_setting,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+}
+
+type ExtensionPointCollection struct {
+	Collection
+	Data   []ExtensionPoint `json:"data,omitempty"`
+	client *ExtensionPointClient
+}
+
+type ExtensionPointClient struct {
+	rancherClient *RancherClient
+}
+
+type ExtensionPointOperations interface {
+	List(opts *ListOpts) (*ExtensionPointCollection, error)
+	Create(opts *ExtensionPoint) (*ExtensionPoint, error)
+	Update(existing *ExtensionPoint, updates interface{}) (*ExtensionPoint, error)
+	ById(id string) (*ExtensionPoint, error)
+	Delete(container *ExtensionPoint) error
+}
+
+func newExtensionPointClient(rancherClient *RancherClient) *ExtensionPointClient {
+	return &ExtensionPointClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExtensionPointClient) Create(container *ExtensionPoint) (*ExtensionPoint, error) {
+	resp := &ExtensionPoint{}
+	err := c.rancherClient.doCreate(EXTENSION_POINT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExtensionPointClient) Update(existing *ExtensionPoint, updates interface{}) (*ExtensionPoint, error) {
+	resp := &ExtensionPoint{}
+	err := c.rancherClient.doUpdate(EXTENSION_POINT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExtensionPointClient) List(opts *ListOpts) (*ExtensionPointCollection, error) {
+	resp := &ExtensionPointCollection{}
+	err := c.rancherClient.doList(EXTENSION_POINT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExtensionPointCollection) Next() (*ExtensionPointCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExtensionPointCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExtensionPointClient) ById(id string) (*ExtensionPoint, error) {
+	resp := &ExtensionPoint{}
+	err := c.rancherClient.doById(EXTENSION_POINT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExtensionPointClient) Delete(container *ExtensionPoint) error {
+	return c.rancherClient.doResourceDelete(EXTENSION_POINT_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_dns_event.go

@@ -0,0 +1,129 @@
+package client
+
+const (
+	EXTERNAL_DNS_EVENT_TYPE = "externalDnsEvent"
+)
+
+type ExternalDnsEvent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
+
+	ServiceName string `json:"serviceName,omitempty" yaml:"service_name,omitempty"`
+
+	StackName string `json:"stackName,omitempty" yaml:"stack_name,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalDnsEventCollection struct {
+	Collection
+	Data   []ExternalDnsEvent `json:"data,omitempty"`
+	client *ExternalDnsEventClient
+}
+
+type ExternalDnsEventClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalDnsEventOperations interface {
+	List(opts *ListOpts) (*ExternalDnsEventCollection, error)
+	Create(opts *ExternalDnsEvent) (*ExternalDnsEvent, error)
+	Update(existing *ExternalDnsEvent, updates interface{}) (*ExternalDnsEvent, error)
+	ById(id string) (*ExternalDnsEvent, error)
+	Delete(container *ExternalDnsEvent) error
+
+	ActionCreate(*ExternalDnsEvent) (*ExternalEvent, error)
+
+	ActionRemove(*ExternalDnsEvent) (*ExternalEvent, error)
+}
+
+func newExternalDnsEventClient(rancherClient *RancherClient) *ExternalDnsEventClient {
+	return &ExternalDnsEventClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalDnsEventClient) Create(container *ExternalDnsEvent) (*ExternalDnsEvent, error) {
+	resp := &ExternalDnsEvent{}
+	err := c.rancherClient.doCreate(EXTERNAL_DNS_EVENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalDnsEventClient) Update(existing *ExternalDnsEvent, updates interface{}) (*ExternalDnsEvent, error) {
+	resp := &ExternalDnsEvent{}
+	err := c.rancherClient.doUpdate(EXTERNAL_DNS_EVENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalDnsEventClient) List(opts *ListOpts) (*ExternalDnsEventCollection, error) {
+	resp := &ExternalDnsEventCollection{}
+	err := c.rancherClient.doList(EXTERNAL_DNS_EVENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalDnsEventCollection) Next() (*ExternalDnsEventCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalDnsEventCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalDnsEventClient) ById(id string) (*ExternalDnsEvent, error) {
+	resp := &ExternalDnsEvent{}
+	err := c.rancherClient.doById(EXTERNAL_DNS_EVENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalDnsEventClient) Delete(container *ExternalDnsEvent) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_DNS_EVENT_TYPE, &container.Resource)
+}
+
+func (c *ExternalDnsEventClient) ActionCreate(resource *ExternalDnsEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_DNS_EVENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalDnsEventClient) ActionRemove(resource *ExternalDnsEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_DNS_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_event.go

@@ -0,0 +1,123 @@
+package client
+
+const (
+	EXTERNAL_EVENT_TYPE = "externalEvent"
+)
+
+type ExternalEvent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalEventCollection struct {
+	Collection
+	Data   []ExternalEvent `json:"data,omitempty"`
+	client *ExternalEventClient
+}
+
+type ExternalEventClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalEventOperations interface {
+	List(opts *ListOpts) (*ExternalEventCollection, error)
+	Create(opts *ExternalEvent) (*ExternalEvent, error)
+	Update(existing *ExternalEvent, updates interface{}) (*ExternalEvent, error)
+	ById(id string) (*ExternalEvent, error)
+	Delete(container *ExternalEvent) error
+
+	ActionCreate(*ExternalEvent) (*ExternalEvent, error)
+
+	ActionRemove(*ExternalEvent) (*ExternalEvent, error)
+}
+
+func newExternalEventClient(rancherClient *RancherClient) *ExternalEventClient {
+	return &ExternalEventClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalEventClient) Create(container *ExternalEvent) (*ExternalEvent, error) {
+	resp := &ExternalEvent{}
+	err := c.rancherClient.doCreate(EXTERNAL_EVENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalEventClient) Update(existing *ExternalEvent, updates interface{}) (*ExternalEvent, error) {
+	resp := &ExternalEvent{}
+	err := c.rancherClient.doUpdate(EXTERNAL_EVENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalEventClient) List(opts *ListOpts) (*ExternalEventCollection, error) {
+	resp := &ExternalEventCollection{}
+	err := c.rancherClient.doList(EXTERNAL_EVENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalEventCollection) Next() (*ExternalEventCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalEventCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalEventClient) ById(id string) (*ExternalEvent, error) {
+	resp := &ExternalEvent{}
+	err := c.rancherClient.doById(EXTERNAL_EVENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalEventClient) Delete(container *ExternalEvent) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_EVENT_TYPE, &container.Resource)
+}
+
+func (c *ExternalEventClient) ActionCreate(resource *ExternalEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_EVENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalEventClient) ActionRemove(resource *ExternalEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_handler.go

@@ -0,0 +1,175 @@
+package client
+
+const (
+	EXTERNAL_HANDLER_TYPE = "externalHandler"
+)
+
+type ExternalHandler struct {
+	Resource
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Priority int64 `json:"priority,omitempty" yaml:"priority,omitempty"`
+
+	ProcessConfigs []ExternalHandlerProcessConfig `json:"processConfigs,omitempty" yaml:"process_configs,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	Retries int64 `json:"retries,omitempty" yaml:"retries,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	TimeoutMillis int64 `json:"timeoutMillis,omitempty" yaml:"timeout_millis,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalHandlerCollection struct {
+	Collection
+	Data   []ExternalHandler `json:"data,omitempty"`
+	client *ExternalHandlerClient
+}
+
+type ExternalHandlerClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalHandlerOperations interface {
+	List(opts *ListOpts) (*ExternalHandlerCollection, error)
+	Create(opts *ExternalHandler) (*ExternalHandler, error)
+	Update(existing *ExternalHandler, updates interface{}) (*ExternalHandler, error)
+	ById(id string) (*ExternalHandler, error)
+	Delete(container *ExternalHandler) error
+
+	ActionActivate(*ExternalHandler) (*ExternalHandler, error)
+
+	ActionCreate(*ExternalHandler) (*ExternalHandler, error)
+
+	ActionDeactivate(*ExternalHandler) (*ExternalHandler, error)
+
+	ActionPurge(*ExternalHandler) (*ExternalHandler, error)
+
+	ActionRemove(*ExternalHandler) (*ExternalHandler, error)
+
+	ActionUpdate(*ExternalHandler) (*ExternalHandler, error)
+}
+
+func newExternalHandlerClient(rancherClient *RancherClient) *ExternalHandlerClient {
+	return &ExternalHandlerClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalHandlerClient) Create(container *ExternalHandler) (*ExternalHandler, error) {
+	resp := &ExternalHandler{}
+	err := c.rancherClient.doCreate(EXTERNAL_HANDLER_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) Update(existing *ExternalHandler, updates interface{}) (*ExternalHandler, error) {
+	resp := &ExternalHandler{}
+	err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) List(opts *ListOpts) (*ExternalHandlerCollection, error) {
+	resp := &ExternalHandlerCollection{}
+	err := c.rancherClient.doList(EXTERNAL_HANDLER_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalHandlerCollection) Next() (*ExternalHandlerCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalHandlerCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalHandlerClient) ById(id string) (*ExternalHandler, error) {
+	resp := &ExternalHandler{}
+	err := c.rancherClient.doById(EXTERNAL_HANDLER_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) Delete(container *ExternalHandler) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_TYPE, &container.Resource)
+}
+
+func (c *ExternalHandlerClient) ActionActivate(resource *ExternalHandler) (*ExternalHandler, error) {
+
+	resp := &ExternalHandler{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) ActionCreate(resource *ExternalHandler) (*ExternalHandler, error) {
+
+	resp := &ExternalHandler{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) ActionDeactivate(resource *ExternalHandler) (*ExternalHandler, error) {
+
+	resp := &ExternalHandler{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) ActionPurge(resource *ExternalHandler) (*ExternalHandler, error) {
+
+	resp := &ExternalHandler{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) ActionRemove(resource *ExternalHandler) (*ExternalHandler, error) {
+
+	resp := &ExternalHandler{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerClient) ActionUpdate(resource *ExternalHandler) (*ExternalHandler, error) {
+
+	resp := &ExternalHandler{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_handler_external_handler_process_map.go

@@ -0,0 +1,175 @@
+package client
+
+const (
+	EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE = "externalHandlerExternalHandlerProcessMap"
+)
+
+type ExternalHandlerExternalHandlerProcessMap struct {
+	Resource
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	EventName string `json:"eventName,omitempty" yaml:"event_name,omitempty"`
+
+	ExternalHandlerId string `json:"externalHandlerId,omitempty" yaml:"external_handler_id,omitempty"`
+
+	ExternalHandlerProcessId string `json:"externalHandlerProcessId,omitempty" yaml:"external_handler_process_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	OnError string `json:"onError,omitempty" yaml:"on_error,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalHandlerExternalHandlerProcessMapCollection struct {
+	Collection
+	Data   []ExternalHandlerExternalHandlerProcessMap `json:"data,omitempty"`
+	client *ExternalHandlerExternalHandlerProcessMapClient
+}
+
+type ExternalHandlerExternalHandlerProcessMapClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalHandlerExternalHandlerProcessMapOperations interface {
+	List(opts *ListOpts) (*ExternalHandlerExternalHandlerProcessMapCollection, error)
+	Create(opts *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
+	Update(existing *ExternalHandlerExternalHandlerProcessMap, updates interface{}) (*ExternalHandlerExternalHandlerProcessMap, error)
+	ById(id string) (*ExternalHandlerExternalHandlerProcessMap, error)
+	Delete(container *ExternalHandlerExternalHandlerProcessMap) error
+
+	ActionActivate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
+
+	ActionCreate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
+
+	ActionDeactivate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
+
+	ActionPurge(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
+
+	ActionRemove(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
+
+	ActionUpdate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
+}
+
+func newExternalHandlerExternalHandlerProcessMapClient(rancherClient *RancherClient) *ExternalHandlerExternalHandlerProcessMapClient {
+	return &ExternalHandlerExternalHandlerProcessMapClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) Create(container *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+	err := c.rancherClient.doCreate(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) Update(existing *ExternalHandlerExternalHandlerProcessMap, updates interface{}) (*ExternalHandlerExternalHandlerProcessMap, error) {
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+	err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) List(opts *ListOpts) (*ExternalHandlerExternalHandlerProcessMapCollection, error) {
+	resp := &ExternalHandlerExternalHandlerProcessMapCollection{}
+	err := c.rancherClient.doList(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalHandlerExternalHandlerProcessMapCollection) Next() (*ExternalHandlerExternalHandlerProcessMapCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalHandlerExternalHandlerProcessMapCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) ById(id string) (*ExternalHandlerExternalHandlerProcessMap, error) {
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+	err := c.rancherClient.doById(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) Delete(container *ExternalHandlerExternalHandlerProcessMap) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, &container.Resource)
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionActivate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
+
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionCreate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
+
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionDeactivate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
+
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionPurge(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
+
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionRemove(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
+
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionUpdate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
+
+	resp := &ExternalHandlerExternalHandlerProcessMap{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_handler_process.go

@@ -0,0 +1,167 @@
+package client
+
+const (
+	EXTERNAL_HANDLER_PROCESS_TYPE = "externalHandlerProcess"
+)
+
+type ExternalHandlerProcess struct {
+	Resource
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalHandlerProcessCollection struct {
+	Collection
+	Data   []ExternalHandlerProcess `json:"data,omitempty"`
+	client *ExternalHandlerProcessClient
+}
+
+type ExternalHandlerProcessClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalHandlerProcessOperations interface {
+	List(opts *ListOpts) (*ExternalHandlerProcessCollection, error)
+	Create(opts *ExternalHandlerProcess) (*ExternalHandlerProcess, error)
+	Update(existing *ExternalHandlerProcess, updates interface{}) (*ExternalHandlerProcess, error)
+	ById(id string) (*ExternalHandlerProcess, error)
+	Delete(container *ExternalHandlerProcess) error
+
+	ActionActivate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
+
+	ActionCreate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
+
+	ActionDeactivate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
+
+	ActionPurge(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
+
+	ActionRemove(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
+
+	ActionUpdate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
+}
+
+func newExternalHandlerProcessClient(rancherClient *RancherClient) *ExternalHandlerProcessClient {
+	return &ExternalHandlerProcessClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalHandlerProcessClient) Create(container *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
+	resp := &ExternalHandlerProcess{}
+	err := c.rancherClient.doCreate(EXTERNAL_HANDLER_PROCESS_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) Update(existing *ExternalHandlerProcess, updates interface{}) (*ExternalHandlerProcess, error) {
+	resp := &ExternalHandlerProcess{}
+	err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_PROCESS_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) List(opts *ListOpts) (*ExternalHandlerProcessCollection, error) {
+	resp := &ExternalHandlerProcessCollection{}
+	err := c.rancherClient.doList(EXTERNAL_HANDLER_PROCESS_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalHandlerProcessCollection) Next() (*ExternalHandlerProcessCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalHandlerProcessCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalHandlerProcessClient) ById(id string) (*ExternalHandlerProcess, error) {
+	resp := &ExternalHandlerProcess{}
+	err := c.rancherClient.doById(EXTERNAL_HANDLER_PROCESS_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) Delete(container *ExternalHandlerProcess) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_PROCESS_TYPE, &container.Resource)
+}
+
+func (c *ExternalHandlerProcessClient) ActionActivate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
+
+	resp := &ExternalHandlerProcess{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) ActionCreate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
+
+	resp := &ExternalHandlerProcess{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) ActionDeactivate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
+
+	resp := &ExternalHandlerProcess{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) ActionPurge(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
+
+	resp := &ExternalHandlerProcess{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) ActionRemove(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
+
+	resp := &ExternalHandlerProcess{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessClient) ActionUpdate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
+
+	resp := &ExternalHandlerProcess{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_handler_process_config.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE = "externalHandlerProcessConfig"
+)
+
+type ExternalHandlerProcessConfig struct {
+	Resource
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	OnError string `json:"onError,omitempty" yaml:"on_error,omitempty"`
+}
+
+type ExternalHandlerProcessConfigCollection struct {
+	Collection
+	Data   []ExternalHandlerProcessConfig `json:"data,omitempty"`
+	client *ExternalHandlerProcessConfigClient
+}
+
+type ExternalHandlerProcessConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalHandlerProcessConfigOperations interface {
+	List(opts *ListOpts) (*ExternalHandlerProcessConfigCollection, error)
+	Create(opts *ExternalHandlerProcessConfig) (*ExternalHandlerProcessConfig, error)
+	Update(existing *ExternalHandlerProcessConfig, updates interface{}) (*ExternalHandlerProcessConfig, error)
+	ById(id string) (*ExternalHandlerProcessConfig, error)
+	Delete(container *ExternalHandlerProcessConfig) error
+}
+
+func newExternalHandlerProcessConfigClient(rancherClient *RancherClient) *ExternalHandlerProcessConfigClient {
+	return &ExternalHandlerProcessConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalHandlerProcessConfigClient) Create(container *ExternalHandlerProcessConfig) (*ExternalHandlerProcessConfig, error) {
+	resp := &ExternalHandlerProcessConfig{}
+	err := c.rancherClient.doCreate(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessConfigClient) Update(existing *ExternalHandlerProcessConfig, updates interface{}) (*ExternalHandlerProcessConfig, error) {
+	resp := &ExternalHandlerProcessConfig{}
+	err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessConfigClient) List(opts *ListOpts) (*ExternalHandlerProcessConfigCollection, error) {
+	resp := &ExternalHandlerProcessConfigCollection{}
+	err := c.rancherClient.doList(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalHandlerProcessConfigCollection) Next() (*ExternalHandlerProcessConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalHandlerProcessConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalHandlerProcessConfigClient) ById(id string) (*ExternalHandlerProcessConfig, error) {
+	resp := &ExternalHandlerProcessConfig{}
+	err := c.rancherClient.doById(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalHandlerProcessConfigClient) Delete(container *ExternalHandlerProcessConfig) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_host_event.go

@@ -0,0 +1,129 @@
+package client
+
+const (
+	EXTERNAL_HOST_EVENT_TYPE = "externalHostEvent"
+)
+
+type ExternalHostEvent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DeleteHost bool `json:"deleteHost,omitempty" yaml:"delete_host,omitempty"`
+
+	EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
+
+	HostLabel string `json:"hostLabel,omitempty" yaml:"host_label,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalHostEventCollection struct {
+	Collection
+	Data   []ExternalHostEvent `json:"data,omitempty"`
+	client *ExternalHostEventClient
+}
+
+type ExternalHostEventClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalHostEventOperations interface {
+	List(opts *ListOpts) (*ExternalHostEventCollection, error)
+	Create(opts *ExternalHostEvent) (*ExternalHostEvent, error)
+	Update(existing *ExternalHostEvent, updates interface{}) (*ExternalHostEvent, error)
+	ById(id string) (*ExternalHostEvent, error)
+	Delete(container *ExternalHostEvent) error
+
+	ActionCreate(*ExternalHostEvent) (*ExternalEvent, error)
+
+	ActionRemove(*ExternalHostEvent) (*ExternalEvent, error)
+}
+
+func newExternalHostEventClient(rancherClient *RancherClient) *ExternalHostEventClient {
+	return &ExternalHostEventClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalHostEventClient) Create(container *ExternalHostEvent) (*ExternalHostEvent, error) {
+	resp := &ExternalHostEvent{}
+	err := c.rancherClient.doCreate(EXTERNAL_HOST_EVENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalHostEventClient) Update(existing *ExternalHostEvent, updates interface{}) (*ExternalHostEvent, error) {
+	resp := &ExternalHostEvent{}
+	err := c.rancherClient.doUpdate(EXTERNAL_HOST_EVENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalHostEventClient) List(opts *ListOpts) (*ExternalHostEventCollection, error) {
+	resp := &ExternalHostEventCollection{}
+	err := c.rancherClient.doList(EXTERNAL_HOST_EVENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalHostEventCollection) Next() (*ExternalHostEventCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalHostEventCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalHostEventClient) ById(id string) (*ExternalHostEvent, error) {
+	resp := &ExternalHostEvent{}
+	err := c.rancherClient.doById(EXTERNAL_HOST_EVENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalHostEventClient) Delete(container *ExternalHostEvent) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_HOST_EVENT_TYPE, &container.Resource)
+}
+
+func (c *ExternalHostEventClient) ActionCreate(resource *ExternalHostEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HOST_EVENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalHostEventClient) ActionRemove(resource *ExternalHostEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_HOST_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_service.go

@@ -0,0 +1,252 @@
+package client
+
+const (
+	EXTERNAL_SERVICE_TYPE = "externalService"
+)
+
+type ExternalService struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	ExternalIpAddresses []string `json:"externalIpAddresses,omitempty" yaml:"external_ip_addresses,omitempty"`
+
+	Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
+
+	HealthCheck *InstanceHealthCheck `json:"healthCheck,omitempty" yaml:"health_check,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
+
+	InstanceIds []string `json:"instanceIds,omitempty" yaml:"instance_ids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
+
+	LinkedServices map[string]interface{} `json:"linkedServices,omitempty" yaml:"linked_services,omitempty"`
+
+	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Upgrade *ServiceUpgrade `json:"upgrade,omitempty" yaml:"upgrade,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalServiceCollection struct {
+	Collection
+	Data   []ExternalService `json:"data,omitempty"`
+	client *ExternalServiceClient
+}
+
+type ExternalServiceClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalServiceOperations interface {
+	List(opts *ListOpts) (*ExternalServiceCollection, error)
+	Create(opts *ExternalService) (*ExternalService, error)
+	Update(existing *ExternalService, updates interface{}) (*ExternalService, error)
+	ById(id string) (*ExternalService, error)
+	Delete(container *ExternalService) error
+
+	ActionActivate(*ExternalService) (*Service, error)
+
+	ActionCancelupgrade(*ExternalService) (*Service, error)
+
+	ActionContinueupgrade(*ExternalService) (*Service, error)
+
+	ActionCreate(*ExternalService) (*Service, error)
+
+	ActionDeactivate(*ExternalService) (*Service, error)
+
+	ActionFinishupgrade(*ExternalService) (*Service, error)
+
+	ActionRemove(*ExternalService) (*Service, error)
+
+	ActionRestart(*ExternalService, *ServiceRestart) (*Service, error)
+
+	ActionRollback(*ExternalService) (*Service, error)
+
+	ActionUpdate(*ExternalService) (*Service, error)
+
+	ActionUpgrade(*ExternalService, *ServiceUpgrade) (*Service, error)
+}
+
+func newExternalServiceClient(rancherClient *RancherClient) *ExternalServiceClient {
+	return &ExternalServiceClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalServiceClient) Create(container *ExternalService) (*ExternalService, error) {
+	resp := &ExternalService{}
+	err := c.rancherClient.doCreate(EXTERNAL_SERVICE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalServiceClient) Update(existing *ExternalService, updates interface{}) (*ExternalService, error) {
+	resp := &ExternalService{}
+	err := c.rancherClient.doUpdate(EXTERNAL_SERVICE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalServiceClient) List(opts *ListOpts) (*ExternalServiceCollection, error) {
+	resp := &ExternalServiceCollection{}
+	err := c.rancherClient.doList(EXTERNAL_SERVICE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalServiceCollection) Next() (*ExternalServiceCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalServiceCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalServiceClient) ById(id string) (*ExternalService, error) {
+	resp := &ExternalService{}
+	err := c.rancherClient.doById(EXTERNAL_SERVICE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalServiceClient) Delete(container *ExternalService) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_SERVICE_TYPE, &container.Resource)
+}
+
+func (c *ExternalServiceClient) ActionActivate(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionCancelupgrade(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionContinueupgrade(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "continueupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionCreate(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionDeactivate(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionFinishupgrade(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionRemove(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionRestart(resource *ExternalService, input *ServiceRestart) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionRollback(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionUpdate(resource *ExternalService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceClient) ActionUpgrade(resource *ExternalService, input *ServiceUpgrade) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_service_event.go

@@ -0,0 +1,127 @@
+package client
+
+const (
+	EXTERNAL_SERVICE_EVENT_TYPE = "externalServiceEvent"
+)
+
+type ExternalServiceEvent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Environment interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
+
+	EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
+
+	Service interface{} `json:"service,omitempty" yaml:"service,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalServiceEventCollection struct {
+	Collection
+	Data   []ExternalServiceEvent `json:"data,omitempty"`
+	client *ExternalServiceEventClient
+}
+
+type ExternalServiceEventClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalServiceEventOperations interface {
+	List(opts *ListOpts) (*ExternalServiceEventCollection, error)
+	Create(opts *ExternalServiceEvent) (*ExternalServiceEvent, error)
+	Update(existing *ExternalServiceEvent, updates interface{}) (*ExternalServiceEvent, error)
+	ById(id string) (*ExternalServiceEvent, error)
+	Delete(container *ExternalServiceEvent) error
+
+	ActionCreate(*ExternalServiceEvent) (*ExternalEvent, error)
+
+	ActionRemove(*ExternalServiceEvent) (*ExternalEvent, error)
+}
+
+func newExternalServiceEventClient(rancherClient *RancherClient) *ExternalServiceEventClient {
+	return &ExternalServiceEventClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalServiceEventClient) Create(container *ExternalServiceEvent) (*ExternalServiceEvent, error) {
+	resp := &ExternalServiceEvent{}
+	err := c.rancherClient.doCreate(EXTERNAL_SERVICE_EVENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalServiceEventClient) Update(existing *ExternalServiceEvent, updates interface{}) (*ExternalServiceEvent, error) {
+	resp := &ExternalServiceEvent{}
+	err := c.rancherClient.doUpdate(EXTERNAL_SERVICE_EVENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalServiceEventClient) List(opts *ListOpts) (*ExternalServiceEventCollection, error) {
+	resp := &ExternalServiceEventCollection{}
+	err := c.rancherClient.doList(EXTERNAL_SERVICE_EVENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalServiceEventCollection) Next() (*ExternalServiceEventCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalServiceEventCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalServiceEventClient) ById(id string) (*ExternalServiceEvent, error) {
+	resp := &ExternalServiceEvent{}
+	err := c.rancherClient.doById(EXTERNAL_SERVICE_EVENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalServiceEventClient) Delete(container *ExternalServiceEvent) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_SERVICE_EVENT_TYPE, &container.Resource)
+}
+
+func (c *ExternalServiceEventClient) ActionCreate(resource *ExternalServiceEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_EVENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalServiceEventClient) ActionRemove(resource *ExternalServiceEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_SERVICE_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_storage_pool_event.go

@@ -0,0 +1,127 @@
+package client
+
+const (
+	EXTERNAL_STORAGE_POOL_EVENT_TYPE = "externalStoragePoolEvent"
+)
+
+type ExternalStoragePoolEvent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	HostUuids []string `json:"hostUuids,omitempty" yaml:"host_uuids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	StoragePool StoragePool `json:"storagePool,omitempty" yaml:"storage_pool,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ExternalStoragePoolEventCollection struct {
+	Collection
+	Data   []ExternalStoragePoolEvent `json:"data,omitempty"`
+	client *ExternalStoragePoolEventClient
+}
+
+type ExternalStoragePoolEventClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalStoragePoolEventOperations interface {
+	List(opts *ListOpts) (*ExternalStoragePoolEventCollection, error)
+	Create(opts *ExternalStoragePoolEvent) (*ExternalStoragePoolEvent, error)
+	Update(existing *ExternalStoragePoolEvent, updates interface{}) (*ExternalStoragePoolEvent, error)
+	ById(id string) (*ExternalStoragePoolEvent, error)
+	Delete(container *ExternalStoragePoolEvent) error
+
+	ActionCreate(*ExternalStoragePoolEvent) (*ExternalEvent, error)
+
+	ActionRemove(*ExternalStoragePoolEvent) (*ExternalEvent, error)
+}
+
+func newExternalStoragePoolEventClient(rancherClient *RancherClient) *ExternalStoragePoolEventClient {
+	return &ExternalStoragePoolEventClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalStoragePoolEventClient) Create(container *ExternalStoragePoolEvent) (*ExternalStoragePoolEvent, error) {
+	resp := &ExternalStoragePoolEvent{}
+	err := c.rancherClient.doCreate(EXTERNAL_STORAGE_POOL_EVENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalStoragePoolEventClient) Update(existing *ExternalStoragePoolEvent, updates interface{}) (*ExternalStoragePoolEvent, error) {
+	resp := &ExternalStoragePoolEvent{}
+	err := c.rancherClient.doUpdate(EXTERNAL_STORAGE_POOL_EVENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalStoragePoolEventClient) List(opts *ListOpts) (*ExternalStoragePoolEventCollection, error) {
+	resp := &ExternalStoragePoolEventCollection{}
+	err := c.rancherClient.doList(EXTERNAL_STORAGE_POOL_EVENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalStoragePoolEventCollection) Next() (*ExternalStoragePoolEventCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalStoragePoolEventCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalStoragePoolEventClient) ById(id string) (*ExternalStoragePoolEvent, error) {
+	resp := &ExternalStoragePoolEvent{}
+	err := c.rancherClient.doById(EXTERNAL_STORAGE_POOL_EVENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalStoragePoolEventClient) Delete(container *ExternalStoragePoolEvent) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_STORAGE_POOL_EVENT_TYPE, &container.Resource)
+}
+
+func (c *ExternalStoragePoolEventClient) ActionCreate(resource *ExternalStoragePoolEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_STORAGE_POOL_EVENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalStoragePoolEventClient) ActionRemove(resource *ExternalStoragePoolEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_STORAGE_POOL_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_external_volume_event.go

@@ -0,0 +1,125 @@
+package client
+
+const (
+	EXTERNAL_VOLUME_EVENT_TYPE = "externalVolumeEvent"
+)
+
+type ExternalVolumeEvent struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Volume Volume `json:"volume,omitempty" yaml:"volume,omitempty"`
+}
+
+type ExternalVolumeEventCollection struct {
+	Collection
+	Data   []ExternalVolumeEvent `json:"data,omitempty"`
+	client *ExternalVolumeEventClient
+}
+
+type ExternalVolumeEventClient struct {
+	rancherClient *RancherClient
+}
+
+type ExternalVolumeEventOperations interface {
+	List(opts *ListOpts) (*ExternalVolumeEventCollection, error)
+	Create(opts *ExternalVolumeEvent) (*ExternalVolumeEvent, error)
+	Update(existing *ExternalVolumeEvent, updates interface{}) (*ExternalVolumeEvent, error)
+	ById(id string) (*ExternalVolumeEvent, error)
+	Delete(container *ExternalVolumeEvent) error
+
+	ActionCreate(*ExternalVolumeEvent) (*ExternalEvent, error)
+
+	ActionRemove(*ExternalVolumeEvent) (*ExternalEvent, error)
+}
+
+func newExternalVolumeEventClient(rancherClient *RancherClient) *ExternalVolumeEventClient {
+	return &ExternalVolumeEventClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ExternalVolumeEventClient) Create(container *ExternalVolumeEvent) (*ExternalVolumeEvent, error) {
+	resp := &ExternalVolumeEvent{}
+	err := c.rancherClient.doCreate(EXTERNAL_VOLUME_EVENT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ExternalVolumeEventClient) Update(existing *ExternalVolumeEvent, updates interface{}) (*ExternalVolumeEvent, error) {
+	resp := &ExternalVolumeEvent{}
+	err := c.rancherClient.doUpdate(EXTERNAL_VOLUME_EVENT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ExternalVolumeEventClient) List(opts *ListOpts) (*ExternalVolumeEventCollection, error) {
+	resp := &ExternalVolumeEventCollection{}
+	err := c.rancherClient.doList(EXTERNAL_VOLUME_EVENT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ExternalVolumeEventCollection) Next() (*ExternalVolumeEventCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ExternalVolumeEventCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ExternalVolumeEventClient) ById(id string) (*ExternalVolumeEvent, error) {
+	resp := &ExternalVolumeEvent{}
+	err := c.rancherClient.doById(EXTERNAL_VOLUME_EVENT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ExternalVolumeEventClient) Delete(container *ExternalVolumeEvent) error {
+	return c.rancherClient.doResourceDelete(EXTERNAL_VOLUME_EVENT_TYPE, &container.Resource)
+}
+
+func (c *ExternalVolumeEventClient) ActionCreate(resource *ExternalVolumeEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_VOLUME_EVENT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ExternalVolumeEventClient) ActionRemove(resource *ExternalVolumeEvent) (*ExternalEvent, error) {
+
+	resp := &ExternalEvent{}
+
+	err := c.rancherClient.doAction(EXTERNAL_VOLUME_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_field_documentation.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	FIELD_DOCUMENTATION_TYPE = "fieldDocumentation"
+)
+
+type FieldDocumentation struct {
+	Resource
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+}
+
+type FieldDocumentationCollection struct {
+	Collection
+	Data   []FieldDocumentation `json:"data,omitempty"`
+	client *FieldDocumentationClient
+}
+
+type FieldDocumentationClient struct {
+	rancherClient *RancherClient
+}
+
+type FieldDocumentationOperations interface {
+	List(opts *ListOpts) (*FieldDocumentationCollection, error)
+	Create(opts *FieldDocumentation) (*FieldDocumentation, error)
+	Update(existing *FieldDocumentation, updates interface{}) (*FieldDocumentation, error)
+	ById(id string) (*FieldDocumentation, error)
+	Delete(container *FieldDocumentation) error
+}
+
+func newFieldDocumentationClient(rancherClient *RancherClient) *FieldDocumentationClient {
+	return &FieldDocumentationClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *FieldDocumentationClient) Create(container *FieldDocumentation) (*FieldDocumentation, error) {
+	resp := &FieldDocumentation{}
+	err := c.rancherClient.doCreate(FIELD_DOCUMENTATION_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *FieldDocumentationClient) Update(existing *FieldDocumentation, updates interface{}) (*FieldDocumentation, error) {
+	resp := &FieldDocumentation{}
+	err := c.rancherClient.doUpdate(FIELD_DOCUMENTATION_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *FieldDocumentationClient) List(opts *ListOpts) (*FieldDocumentationCollection, error) {
+	resp := &FieldDocumentationCollection{}
+	err := c.rancherClient.doList(FIELD_DOCUMENTATION_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *FieldDocumentationCollection) Next() (*FieldDocumentationCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &FieldDocumentationCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *FieldDocumentationClient) ById(id string) (*FieldDocumentation, error) {
+	resp := &FieldDocumentation{}
+	err := c.rancherClient.doById(FIELD_DOCUMENTATION_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *FieldDocumentationClient) Delete(container *FieldDocumentation) error {
+	return c.rancherClient.doResourceDelete(FIELD_DOCUMENTATION_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_generic_object.go

@@ -0,0 +1,129 @@
+package client
+
+const (
+	GENERIC_OBJECT_TYPE = "genericObject"
+)
+
+type GenericObject struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Key string `json:"key,omitempty" yaml:"key,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	ResourceData map[string]interface{} `json:"resourceData,omitempty" yaml:"resource_data,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type GenericObjectCollection struct {
+	Collection
+	Data   []GenericObject `json:"data,omitempty"`
+	client *GenericObjectClient
+}
+
+type GenericObjectClient struct {
+	rancherClient *RancherClient
+}
+
+type GenericObjectOperations interface {
+	List(opts *ListOpts) (*GenericObjectCollection, error)
+	Create(opts *GenericObject) (*GenericObject, error)
+	Update(existing *GenericObject, updates interface{}) (*GenericObject, error)
+	ById(id string) (*GenericObject, error)
+	Delete(container *GenericObject) error
+
+	ActionCreate(*GenericObject) (*GenericObject, error)
+
+	ActionRemove(*GenericObject) (*GenericObject, error)
+}
+
+func newGenericObjectClient(rancherClient *RancherClient) *GenericObjectClient {
+	return &GenericObjectClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *GenericObjectClient) Create(container *GenericObject) (*GenericObject, error) {
+	resp := &GenericObject{}
+	err := c.rancherClient.doCreate(GENERIC_OBJECT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *GenericObjectClient) Update(existing *GenericObject, updates interface{}) (*GenericObject, error) {
+	resp := &GenericObject{}
+	err := c.rancherClient.doUpdate(GENERIC_OBJECT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *GenericObjectClient) List(opts *ListOpts) (*GenericObjectCollection, error) {
+	resp := &GenericObjectCollection{}
+	err := c.rancherClient.doList(GENERIC_OBJECT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *GenericObjectCollection) Next() (*GenericObjectCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &GenericObjectCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *GenericObjectClient) ById(id string) (*GenericObject, error) {
+	resp := &GenericObject{}
+	err := c.rancherClient.doById(GENERIC_OBJECT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *GenericObjectClient) Delete(container *GenericObject) error {
+	return c.rancherClient.doResourceDelete(GENERIC_OBJECT_TYPE, &container.Resource)
+}
+
+func (c *GenericObjectClient) ActionCreate(resource *GenericObject) (*GenericObject, error) {
+
+	resp := &GenericObject{}
+
+	err := c.rancherClient.doAction(GENERIC_OBJECT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *GenericObjectClient) ActionRemove(resource *GenericObject) (*GenericObject, error) {
+
+	resp := &GenericObject{}
+
+	err := c.rancherClient.doAction(GENERIC_OBJECT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_ha_config.go

@@ -0,0 +1,85 @@
+package client
+
+const (
+	HA_CONFIG_TYPE = "haConfig"
+)
+
+type HaConfig struct {
+	Resource
+
+	ClusterSize int64 `json:"clusterSize,omitempty" yaml:"cluster_size,omitempty"`
+
+	DbHost string `json:"dbHost,omitempty" yaml:"db_host,omitempty"`
+
+	DbSize int64 `json:"dbSize,omitempty" yaml:"db_size,omitempty"`
+
+	Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
+}
+
+type HaConfigCollection struct {
+	Collection
+	Data   []HaConfig `json:"data,omitempty"`
+	client *HaConfigClient
+}
+
+type HaConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type HaConfigOperations interface {
+	List(opts *ListOpts) (*HaConfigCollection, error)
+	Create(opts *HaConfig) (*HaConfig, error)
+	Update(existing *HaConfig, updates interface{}) (*HaConfig, error)
+	ById(id string) (*HaConfig, error)
+	Delete(container *HaConfig) error
+}
+
+func newHaConfigClient(rancherClient *RancherClient) *HaConfigClient {
+	return &HaConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *HaConfigClient) Create(container *HaConfig) (*HaConfig, error) {
+	resp := &HaConfig{}
+	err := c.rancherClient.doCreate(HA_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *HaConfigClient) Update(existing *HaConfig, updates interface{}) (*HaConfig, error) {
+	resp := &HaConfig{}
+	err := c.rancherClient.doUpdate(HA_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *HaConfigClient) List(opts *ListOpts) (*HaConfigCollection, error) {
+	resp := &HaConfigCollection{}
+	err := c.rancherClient.doList(HA_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *HaConfigCollection) Next() (*HaConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &HaConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *HaConfigClient) ById(id string) (*HaConfig, error) {
+	resp := &HaConfig{}
+	err := c.rancherClient.doById(HA_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *HaConfigClient) Delete(container *HaConfig) error {
+	return c.rancherClient.doResourceDelete(HA_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_ha_config_input.go

@@ -0,0 +1,109 @@
+package client
+
+const (
+	HA_CONFIG_INPUT_TYPE = "haConfigInput"
+)
+
+type HaConfigInput struct {
+	Resource
+
+	Cert string `json:"cert,omitempty" yaml:"cert,omitempty"`
+
+	CertChain string `json:"certChain,omitempty" yaml:"cert_chain,omitempty"`
+
+	ClusterSize int64 `json:"clusterSize,omitempty" yaml:"cluster_size,omitempty"`
+
+	HostRegistrationUrl string `json:"hostRegistrationUrl,omitempty" yaml:"host_registration_url,omitempty"`
+
+	HttpEnabled bool `json:"httpEnabled,omitempty" yaml:"http_enabled,omitempty"`
+
+	HttpPort int64 `json:"httpPort,omitempty" yaml:"http_port,omitempty"`
+
+	HttpsPort int64 `json:"httpsPort,omitempty" yaml:"https_port,omitempty"`
+
+	Key string `json:"key,omitempty" yaml:"key,omitempty"`
+
+	PpHttpPort int64 `json:"ppHttpPort,omitempty" yaml:"pp_http_port,omitempty"`
+
+	PpHttpsPort int64 `json:"ppHttpsPort,omitempty" yaml:"pp_https_port,omitempty"`
+
+	RedisPort int64 `json:"redisPort,omitempty" yaml:"redis_port,omitempty"`
+
+	SwarmEnabled bool `json:"swarmEnabled,omitempty" yaml:"swarm_enabled,omitempty"`
+
+	SwarmPort int64 `json:"swarmPort,omitempty" yaml:"swarm_port,omitempty"`
+
+	ZookeeperClientPort int64 `json:"zookeeperClientPort,omitempty" yaml:"zookeeper_client_port,omitempty"`
+
+	ZookeeperLeaderPort int64 `json:"zookeeperLeaderPort,omitempty" yaml:"zookeeper_leader_port,omitempty"`
+
+	ZookeeperQuorumPort int64 `json:"zookeeperQuorumPort,omitempty" yaml:"zookeeper_quorum_port,omitempty"`
+}
+
+type HaConfigInputCollection struct {
+	Collection
+	Data   []HaConfigInput `json:"data,omitempty"`
+	client *HaConfigInputClient
+}
+
+type HaConfigInputClient struct {
+	rancherClient *RancherClient
+}
+
+type HaConfigInputOperations interface {
+	List(opts *ListOpts) (*HaConfigInputCollection, error)
+	Create(opts *HaConfigInput) (*HaConfigInput, error)
+	Update(existing *HaConfigInput, updates interface{}) (*HaConfigInput, error)
+	ById(id string) (*HaConfigInput, error)
+	Delete(container *HaConfigInput) error
+}
+
+func newHaConfigInputClient(rancherClient *RancherClient) *HaConfigInputClient {
+	return &HaConfigInputClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *HaConfigInputClient) Create(container *HaConfigInput) (*HaConfigInput, error) {
+	resp := &HaConfigInput{}
+	err := c.rancherClient.doCreate(HA_CONFIG_INPUT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *HaConfigInputClient) Update(existing *HaConfigInput, updates interface{}) (*HaConfigInput, error) {
+	resp := &HaConfigInput{}
+	err := c.rancherClient.doUpdate(HA_CONFIG_INPUT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *HaConfigInputClient) List(opts *ListOpts) (*HaConfigInputCollection, error) {
+	resp := &HaConfigInputCollection{}
+	err := c.rancherClient.doList(HA_CONFIG_INPUT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *HaConfigInputCollection) Next() (*HaConfigInputCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &HaConfigInputCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *HaConfigInputClient) ById(id string) (*HaConfigInput, error) {
+	resp := &HaConfigInput{}
+	err := c.rancherClient.doById(HA_CONFIG_INPUT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *HaConfigInputClient) Delete(container *HaConfigInput) error {
+	return c.rancherClient.doResourceDelete(HA_CONFIG_INPUT_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_healthcheck_instance_host_map.go

@@ -0,0 +1,131 @@
+package client
+
+const (
+	HEALTHCHECK_INSTANCE_HOST_MAP_TYPE = "healthcheckInstanceHostMap"
+)
+
+type HealthcheckInstanceHostMap struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
+
+	InstanceId string `json:"instanceId,omitempty" yaml:"instance_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type HealthcheckInstanceHostMapCollection struct {
+	Collection
+	Data   []HealthcheckInstanceHostMap `json:"data,omitempty"`
+	client *HealthcheckInstanceHostMapClient
+}
+
+type HealthcheckInstanceHostMapClient struct {
+	rancherClient *RancherClient
+}
+
+type HealthcheckInstanceHostMapOperations interface {
+	List(opts *ListOpts) (*HealthcheckInstanceHostMapCollection, error)
+	Create(opts *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error)
+	Update(existing *HealthcheckInstanceHostMap, updates interface{}) (*HealthcheckInstanceHostMap, error)
+	ById(id string) (*HealthcheckInstanceHostMap, error)
+	Delete(container *HealthcheckInstanceHostMap) error
+
+	ActionCreate(*HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error)
+
+	ActionRemove(*HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error)
+}
+
+func newHealthcheckInstanceHostMapClient(rancherClient *RancherClient) *HealthcheckInstanceHostMapClient {
+	return &HealthcheckInstanceHostMapClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *HealthcheckInstanceHostMapClient) Create(container *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error) {
+	resp := &HealthcheckInstanceHostMap{}
+	err := c.rancherClient.doCreate(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *HealthcheckInstanceHostMapClient) Update(existing *HealthcheckInstanceHostMap, updates interface{}) (*HealthcheckInstanceHostMap, error) {
+	resp := &HealthcheckInstanceHostMap{}
+	err := c.rancherClient.doUpdate(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *HealthcheckInstanceHostMapClient) List(opts *ListOpts) (*HealthcheckInstanceHostMapCollection, error) {
+	resp := &HealthcheckInstanceHostMapCollection{}
+	err := c.rancherClient.doList(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *HealthcheckInstanceHostMapCollection) Next() (*HealthcheckInstanceHostMapCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &HealthcheckInstanceHostMapCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *HealthcheckInstanceHostMapClient) ById(id string) (*HealthcheckInstanceHostMap, error) {
+	resp := &HealthcheckInstanceHostMap{}
+	err := c.rancherClient.doById(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *HealthcheckInstanceHostMapClient) Delete(container *HealthcheckInstanceHostMap) error {
+	return c.rancherClient.doResourceDelete(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, &container.Resource)
+}
+
+func (c *HealthcheckInstanceHostMapClient) ActionCreate(resource *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error) {
+
+	resp := &HealthcheckInstanceHostMap{}
+
+	err := c.rancherClient.doAction(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HealthcheckInstanceHostMapClient) ActionRemove(resource *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error) {
+
+	resp := &HealthcheckInstanceHostMap{}
+
+	err := c.rancherClient.doAction(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_host.go

@@ -0,0 +1,275 @@
+package client
+
+const (
+	HOST_TYPE = "host"
+)
+
+type Host struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
+
+	AgentIpAddress string `json:"agentIpAddress,omitempty" yaml:"agent_ip_address,omitempty"`
+
+	AgentState string `json:"agentState,omitempty" yaml:"agent_state,omitempty"`
+
+	Amazonec2Config *Amazonec2Config `json:"amazonec2Config,omitempty" yaml:"amazonec2config,omitempty"`
+
+	ApiProxy string `json:"apiProxy,omitempty" yaml:"api_proxy,omitempty"`
+
+	AuthCertificateAuthority string `json:"authCertificateAuthority,omitempty" yaml:"auth_certificate_authority,omitempty"`
+
+	AuthKey string `json:"authKey,omitempty" yaml:"auth_key,omitempty"`
+
+	AzureConfig *AzureConfig `json:"azureConfig,omitempty" yaml:"azure_config,omitempty"`
+
+	ComputeTotal int64 `json:"computeTotal,omitempty" yaml:"compute_total,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	DigitaloceanConfig *DigitaloceanConfig `json:"digitaloceanConfig,omitempty" yaml:"digitalocean_config,omitempty"`
+
+	DockerVersion string `json:"dockerVersion,omitempty" yaml:"docker_version,omitempty"`
+
+	Driver string `json:"driver,omitempty" yaml:"driver,omitempty"`
+
+	EngineEnv map[string]interface{} `json:"engineEnv,omitempty" yaml:"engine_env,omitempty"`
+
+	EngineInsecureRegistry []string `json:"engineInsecureRegistry,omitempty" yaml:"engine_insecure_registry,omitempty"`
+
+	EngineInstallUrl string `json:"engineInstallUrl,omitempty" yaml:"engine_install_url,omitempty"`
+
+	EngineLabel map[string]interface{} `json:"engineLabel,omitempty" yaml:"engine_label,omitempty"`
+
+	EngineOpt map[string]interface{} `json:"engineOpt,omitempty" yaml:"engine_opt,omitempty"`
+
+	EngineRegistryMirror []string `json:"engineRegistryMirror,omitempty" yaml:"engine_registry_mirror,omitempty"`
+
+	EngineStorageDriver string `json:"engineStorageDriver,omitempty" yaml:"engine_storage_driver,omitempty"`
+
+	HostTemplateId string `json:"hostTemplateId,omitempty" yaml:"host_template_id,omitempty"`
+
+	Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
+
+	Info interface{} `json:"info,omitempty" yaml:"info,omitempty"`
+
+	InstanceIds []string `json:"instanceIds,omitempty" yaml:"instance_ids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Labels map[string]interface{} `json:"labels,omitempty" yaml:"labels,omitempty"`
+
+	LocalStorageMb int64 `json:"localStorageMb,omitempty" yaml:"local_storage_mb,omitempty"`
+
+	Memory int64 `json:"memory,omitempty" yaml:"memory,omitempty"`
+
+	MilliCpu int64 `json:"milliCpu,omitempty" yaml:"milli_cpu,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PacketConfig *PacketConfig `json:"packetConfig,omitempty" yaml:"packet_config,omitempty"`
+
+	PhysicalHostId string `json:"physicalHostId,omitempty" yaml:"physical_host_id,omitempty"`
+
+	PublicEndpoints []PublicEndpoint `json:"publicEndpoints,omitempty" yaml:"public_endpoints,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type HostCollection struct {
+	Collection
+	Data   []Host `json:"data,omitempty"`
+	client *HostClient
+}
+
+type HostClient struct {
+	rancherClient *RancherClient
+}
+
+type HostOperations interface {
+	List(opts *ListOpts) (*HostCollection, error)
+	Create(opts *Host) (*Host, error)
+	Update(existing *Host, updates interface{}) (*Host, error)
+	ById(id string) (*Host, error)
+	Delete(container *Host) error
+
+	ActionActivate(*Host) (*Host, error)
+
+	ActionCreate(*Host) (*Host, error)
+
+	ActionDeactivate(*Host) (*Host, error)
+
+	ActionDockersocket(*Host) (*HostAccess, error)
+
+	ActionError(*Host) (*Host, error)
+
+	ActionEvacuate(*Host) (*Host, error)
+
+	ActionProvision(*Host) (*Host, error)
+
+	ActionPurge(*Host) (*Host, error)
+
+	ActionRemove(*Host) (*Host, error)
+
+	ActionUpdate(*Host) (*Host, error)
+}
+
+func newHostClient(rancherClient *RancherClient) *HostClient {
+	return &HostClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *HostClient) Create(container *Host) (*Host, error) {
+	resp := &Host{}
+	err := c.rancherClient.doCreate(HOST_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *HostClient) Update(existing *Host, updates interface{}) (*Host, error) {
+	resp := &Host{}
+	err := c.rancherClient.doUpdate(HOST_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *HostClient) List(opts *ListOpts) (*HostCollection, error) {
+	resp := &HostCollection{}
+	err := c.rancherClient.doList(HOST_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *HostCollection) Next() (*HostCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &HostCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *HostClient) ById(id string) (*Host, error) {
+	resp := &Host{}
+	err := c.rancherClient.doById(HOST_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *HostClient) Delete(container *Host) error {
+	return c.rancherClient.doResourceDelete(HOST_TYPE, &container.Resource)
+}
+
+func (c *HostClient) ActionActivate(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionCreate(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionDeactivate(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionDockersocket(resource *Host) (*HostAccess, error) {
+
+	resp := &HostAccess{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "dockersocket", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionError(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionEvacuate(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "evacuate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionProvision(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "provision", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionPurge(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionRemove(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostClient) ActionUpdate(resource *Host) (*Host, error) {
+
+	resp := &Host{}
+
+	err := c.rancherClient.doAction(HOST_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_host_access.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	HOST_ACCESS_TYPE = "hostAccess"
+)
+
+type HostAccess struct {
+	Resource
+
+	Token string `json:"token,omitempty" yaml:"token,omitempty"`
+
+	Url string `json:"url,omitempty" yaml:"url,omitempty"`
+}
+
+type HostAccessCollection struct {
+	Collection
+	Data   []HostAccess `json:"data,omitempty"`
+	client *HostAccessClient
+}
+
+type HostAccessClient struct {
+	rancherClient *RancherClient
+}
+
+type HostAccessOperations interface {
+	List(opts *ListOpts) (*HostAccessCollection, error)
+	Create(opts *HostAccess) (*HostAccess, error)
+	Update(existing *HostAccess, updates interface{}) (*HostAccess, error)
+	ById(id string) (*HostAccess, error)
+	Delete(container *HostAccess) error
+}
+
+func newHostAccessClient(rancherClient *RancherClient) *HostAccessClient {
+	return &HostAccessClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *HostAccessClient) Create(container *HostAccess) (*HostAccess, error) {
+	resp := &HostAccess{}
+	err := c.rancherClient.doCreate(HOST_ACCESS_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *HostAccessClient) Update(existing *HostAccess, updates interface{}) (*HostAccess, error) {
+	resp := &HostAccess{}
+	err := c.rancherClient.doUpdate(HOST_ACCESS_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *HostAccessClient) List(opts *ListOpts) (*HostAccessCollection, error) {
+	resp := &HostAccessCollection{}
+	err := c.rancherClient.doList(HOST_ACCESS_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *HostAccessCollection) Next() (*HostAccessCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &HostAccessCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *HostAccessClient) ById(id string) (*HostAccess, error) {
+	resp := &HostAccess{}
+	err := c.rancherClient.doById(HOST_ACCESS_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *HostAccessClient) Delete(container *HostAccess) error {
+	return c.rancherClient.doResourceDelete(HOST_ACCESS_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_host_api_proxy_token.go

@@ -0,0 +1,83 @@
+package client
+
+const (
+	HOST_API_PROXY_TOKEN_TYPE = "hostApiProxyToken"
+)
+
+type HostApiProxyToken struct {
+	Resource
+
+	ReportedUuid string `json:"reportedUuid,omitempty" yaml:"reported_uuid,omitempty"`
+
+	Token string `json:"token,omitempty" yaml:"token,omitempty"`
+
+	Url string `json:"url,omitempty" yaml:"url,omitempty"`
+}
+
+type HostApiProxyTokenCollection struct {
+	Collection
+	Data   []HostApiProxyToken `json:"data,omitempty"`
+	client *HostApiProxyTokenClient
+}
+
+type HostApiProxyTokenClient struct {
+	rancherClient *RancherClient
+}
+
+type HostApiProxyTokenOperations interface {
+	List(opts *ListOpts) (*HostApiProxyTokenCollection, error)
+	Create(opts *HostApiProxyToken) (*HostApiProxyToken, error)
+	Update(existing *HostApiProxyToken, updates interface{}) (*HostApiProxyToken, error)
+	ById(id string) (*HostApiProxyToken, error)
+	Delete(container *HostApiProxyToken) error
+}
+
+func newHostApiProxyTokenClient(rancherClient *RancherClient) *HostApiProxyTokenClient {
+	return &HostApiProxyTokenClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *HostApiProxyTokenClient) Create(container *HostApiProxyToken) (*HostApiProxyToken, error) {
+	resp := &HostApiProxyToken{}
+	err := c.rancherClient.doCreate(HOST_API_PROXY_TOKEN_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *HostApiProxyTokenClient) Update(existing *HostApiProxyToken, updates interface{}) (*HostApiProxyToken, error) {
+	resp := &HostApiProxyToken{}
+	err := c.rancherClient.doUpdate(HOST_API_PROXY_TOKEN_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *HostApiProxyTokenClient) List(opts *ListOpts) (*HostApiProxyTokenCollection, error) {
+	resp := &HostApiProxyTokenCollection{}
+	err := c.rancherClient.doList(HOST_API_PROXY_TOKEN_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *HostApiProxyTokenCollection) Next() (*HostApiProxyTokenCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &HostApiProxyTokenCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *HostApiProxyTokenClient) ById(id string) (*HostApiProxyToken, error) {
+	resp := &HostApiProxyToken{}
+	err := c.rancherClient.doById(HOST_API_PROXY_TOKEN_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *HostApiProxyTokenClient) Delete(container *HostApiProxyToken) error {
+	return c.rancherClient.doResourceDelete(HOST_API_PROXY_TOKEN_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_host_template.go

@@ -0,0 +1,133 @@
+package client
+
+const (
+	HOST_TEMPLATE_TYPE = "hostTemplate"
+)
+
+type HostTemplate struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Driver string `json:"driver,omitempty" yaml:"driver,omitempty"`
+
+	FlavorPrefix string `json:"flavorPrefix,omitempty" yaml:"flavor_prefix,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PublicValues map[string]interface{} `json:"publicValues,omitempty" yaml:"public_values,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	SecretValues map[string]interface{} `json:"secretValues,omitempty" yaml:"secret_values,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type HostTemplateCollection struct {
+	Collection
+	Data   []HostTemplate `json:"data,omitempty"`
+	client *HostTemplateClient
+}
+
+type HostTemplateClient struct {
+	rancherClient *RancherClient
+}
+
+type HostTemplateOperations interface {
+	List(opts *ListOpts) (*HostTemplateCollection, error)
+	Create(opts *HostTemplate) (*HostTemplate, error)
+	Update(existing *HostTemplate, updates interface{}) (*HostTemplate, error)
+	ById(id string) (*HostTemplate, error)
+	Delete(container *HostTemplate) error
+
+	ActionCreate(*HostTemplate) (*HostTemplate, error)
+
+	ActionRemove(*HostTemplate) (*HostTemplate, error)
+}
+
+func newHostTemplateClient(rancherClient *RancherClient) *HostTemplateClient {
+	return &HostTemplateClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *HostTemplateClient) Create(container *HostTemplate) (*HostTemplate, error) {
+	resp := &HostTemplate{}
+	err := c.rancherClient.doCreate(HOST_TEMPLATE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *HostTemplateClient) Update(existing *HostTemplate, updates interface{}) (*HostTemplate, error) {
+	resp := &HostTemplate{}
+	err := c.rancherClient.doUpdate(HOST_TEMPLATE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *HostTemplateClient) List(opts *ListOpts) (*HostTemplateCollection, error) {
+	resp := &HostTemplateCollection{}
+	err := c.rancherClient.doList(HOST_TEMPLATE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *HostTemplateCollection) Next() (*HostTemplateCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &HostTemplateCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *HostTemplateClient) ById(id string) (*HostTemplate, error) {
+	resp := &HostTemplate{}
+	err := c.rancherClient.doById(HOST_TEMPLATE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *HostTemplateClient) Delete(container *HostTemplate) error {
+	return c.rancherClient.doResourceDelete(HOST_TEMPLATE_TYPE, &container.Resource)
+}
+
+func (c *HostTemplateClient) ActionCreate(resource *HostTemplate) (*HostTemplate, error) {
+
+	resp := &HostTemplate{}
+
+	err := c.rancherClient.doAction(HOST_TEMPLATE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *HostTemplateClient) ActionRemove(resource *HostTemplate) (*HostTemplate, error) {
+
+	resp := &HostTemplate{}
+
+	err := c.rancherClient.doAction(HOST_TEMPLATE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_identity.go

@@ -0,0 +1,97 @@
+package client
+
+const (
+	IDENTITY_TYPE = "identity"
+)
+
+type Identity struct {
+	Resource
+
+	All string `json:"all,omitempty" yaml:"all,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	ExternalIdType string `json:"externalIdType,omitempty" yaml:"external_id_type,omitempty"`
+
+	Login string `json:"login,omitempty" yaml:"login,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	ProfilePicture string `json:"profilePicture,omitempty" yaml:"profile_picture,omitempty"`
+
+	ProfileUrl string `json:"profileUrl,omitempty" yaml:"profile_url,omitempty"`
+
+	ProjectId string `json:"projectId,omitempty" yaml:"project_id,omitempty"`
+
+	Role string `json:"role,omitempty" yaml:"role,omitempty"`
+
+	User bool `json:"user,omitempty" yaml:"user,omitempty"`
+}
+
+type IdentityCollection struct {
+	Collection
+	Data   []Identity `json:"data,omitempty"`
+	client *IdentityClient
+}
+
+type IdentityClient struct {
+	rancherClient *RancherClient
+}
+
+type IdentityOperations interface {
+	List(opts *ListOpts) (*IdentityCollection, error)
+	Create(opts *Identity) (*Identity, error)
+	Update(existing *Identity, updates interface{}) (*Identity, error)
+	ById(id string) (*Identity, error)
+	Delete(container *Identity) error
+}
+
+func newIdentityClient(rancherClient *RancherClient) *IdentityClient {
+	return &IdentityClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *IdentityClient) Create(container *Identity) (*Identity, error) {
+	resp := &Identity{}
+	err := c.rancherClient.doCreate(IDENTITY_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *IdentityClient) Update(existing *Identity, updates interface{}) (*Identity, error) {
+	resp := &Identity{}
+	err := c.rancherClient.doUpdate(IDENTITY_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *IdentityClient) List(opts *ListOpts) (*IdentityCollection, error) {
+	resp := &IdentityCollection{}
+	err := c.rancherClient.doList(IDENTITY_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *IdentityCollection) Next() (*IdentityCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &IdentityCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *IdentityClient) ById(id string) (*Identity, error) {
+	resp := &Identity{}
+	err := c.rancherClient.doById(IDENTITY_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *IdentityClient) Delete(container *Identity) error {
+	return c.rancherClient.doResourceDelete(IDENTITY_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_image.go

@@ -0,0 +1,169 @@
+package client
+
+const (
+	IMAGE_TYPE = "image"
+)
+
+type Image struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type ImageCollection struct {
+	Collection
+	Data   []Image `json:"data,omitempty"`
+	client *ImageClient
+}
+
+type ImageClient struct {
+	rancherClient *RancherClient
+}
+
+type ImageOperations interface {
+	List(opts *ListOpts) (*ImageCollection, error)
+	Create(opts *Image) (*Image, error)
+	Update(existing *Image, updates interface{}) (*Image, error)
+	ById(id string) (*Image, error)
+	Delete(container *Image) error
+
+	ActionActivate(*Image) (*Image, error)
+
+	ActionCreate(*Image) (*Image, error)
+
+	ActionDeactivate(*Image) (*Image, error)
+
+	ActionPurge(*Image) (*Image, error)
+
+	ActionRemove(*Image) (*Image, error)
+
+	ActionUpdate(*Image) (*Image, error)
+}
+
+func newImageClient(rancherClient *RancherClient) *ImageClient {
+	return &ImageClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *ImageClient) Create(container *Image) (*Image, error) {
+	resp := &Image{}
+	err := c.rancherClient.doCreate(IMAGE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *ImageClient) Update(existing *Image, updates interface{}) (*Image, error) {
+	resp := &Image{}
+	err := c.rancherClient.doUpdate(IMAGE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *ImageClient) List(opts *ListOpts) (*ImageCollection, error) {
+	resp := &ImageCollection{}
+	err := c.rancherClient.doList(IMAGE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *ImageCollection) Next() (*ImageCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &ImageCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *ImageClient) ById(id string) (*Image, error) {
+	resp := &Image{}
+	err := c.rancherClient.doById(IMAGE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *ImageClient) Delete(container *Image) error {
+	return c.rancherClient.doResourceDelete(IMAGE_TYPE, &container.Resource)
+}
+
+func (c *ImageClient) ActionActivate(resource *Image) (*Image, error) {
+
+	resp := &Image{}
+
+	err := c.rancherClient.doAction(IMAGE_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ImageClient) ActionCreate(resource *Image) (*Image, error) {
+
+	resp := &Image{}
+
+	err := c.rancherClient.doAction(IMAGE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ImageClient) ActionDeactivate(resource *Image) (*Image, error) {
+
+	resp := &Image{}
+
+	err := c.rancherClient.doAction(IMAGE_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ImageClient) ActionPurge(resource *Image) (*Image, error) {
+
+	resp := &Image{}
+
+	err := c.rancherClient.doAction(IMAGE_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ImageClient) ActionRemove(resource *Image) (*Image, error) {
+
+	resp := &Image{}
+
+	err := c.rancherClient.doAction(IMAGE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *ImageClient) ActionUpdate(resource *Image) (*Image, error) {
+
+	resp := &Image{}
+
+	err := c.rancherClient.doAction(IMAGE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_in_service_upgrade_strategy.go

@@ -0,0 +1,91 @@
+package client
+
+const (
+	IN_SERVICE_UPGRADE_STRATEGY_TYPE = "inServiceUpgradeStrategy"
+)
+
+type InServiceUpgradeStrategy struct {
+	Resource
+
+	BatchSize int64 `json:"batchSize,omitempty" yaml:"batch_size,omitempty"`
+
+	IntervalMillis int64 `json:"intervalMillis,omitempty" yaml:"interval_millis,omitempty"`
+
+	LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
+
+	PreviousLaunchConfig *LaunchConfig `json:"previousLaunchConfig,omitempty" yaml:"previous_launch_config,omitempty"`
+
+	PreviousSecondaryLaunchConfigs []SecondaryLaunchConfig `json:"previousSecondaryLaunchConfigs,omitempty" yaml:"previous_secondary_launch_configs,omitempty"`
+
+	SecondaryLaunchConfigs []SecondaryLaunchConfig `json:"secondaryLaunchConfigs,omitempty" yaml:"secondary_launch_configs,omitempty"`
+
+	StartFirst bool `json:"startFirst,omitempty" yaml:"start_first,omitempty"`
+}
+
+type InServiceUpgradeStrategyCollection struct {
+	Collection
+	Data   []InServiceUpgradeStrategy `json:"data,omitempty"`
+	client *InServiceUpgradeStrategyClient
+}
+
+type InServiceUpgradeStrategyClient struct {
+	rancherClient *RancherClient
+}
+
+type InServiceUpgradeStrategyOperations interface {
+	List(opts *ListOpts) (*InServiceUpgradeStrategyCollection, error)
+	Create(opts *InServiceUpgradeStrategy) (*InServiceUpgradeStrategy, error)
+	Update(existing *InServiceUpgradeStrategy, updates interface{}) (*InServiceUpgradeStrategy, error)
+	ById(id string) (*InServiceUpgradeStrategy, error)
+	Delete(container *InServiceUpgradeStrategy) error
+}
+
+func newInServiceUpgradeStrategyClient(rancherClient *RancherClient) *InServiceUpgradeStrategyClient {
+	return &InServiceUpgradeStrategyClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *InServiceUpgradeStrategyClient) Create(container *InServiceUpgradeStrategy) (*InServiceUpgradeStrategy, error) {
+	resp := &InServiceUpgradeStrategy{}
+	err := c.rancherClient.doCreate(IN_SERVICE_UPGRADE_STRATEGY_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *InServiceUpgradeStrategyClient) Update(existing *InServiceUpgradeStrategy, updates interface{}) (*InServiceUpgradeStrategy, error) {
+	resp := &InServiceUpgradeStrategy{}
+	err := c.rancherClient.doUpdate(IN_SERVICE_UPGRADE_STRATEGY_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *InServiceUpgradeStrategyClient) List(opts *ListOpts) (*InServiceUpgradeStrategyCollection, error) {
+	resp := &InServiceUpgradeStrategyCollection{}
+	err := c.rancherClient.doList(IN_SERVICE_UPGRADE_STRATEGY_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *InServiceUpgradeStrategyCollection) Next() (*InServiceUpgradeStrategyCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &InServiceUpgradeStrategyCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *InServiceUpgradeStrategyClient) ById(id string) (*InServiceUpgradeStrategy, error) {
+	resp := &InServiceUpgradeStrategy{}
+	err := c.rancherClient.doById(IN_SERVICE_UPGRADE_STRATEGY_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *InServiceUpgradeStrategyClient) Delete(container *InServiceUpgradeStrategy) error {
+	return c.rancherClient.doResourceDelete(IN_SERVICE_UPGRADE_STRATEGY_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_instance.go

@@ -0,0 +1,272 @@
+package client
+
+const (
+	INSTANCE_TYPE = "instance"
+)
+
+type Instance struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type InstanceCollection struct {
+	Collection
+	Data   []Instance `json:"data,omitempty"`
+	client *InstanceClient
+}
+
+type InstanceClient struct {
+	rancherClient *RancherClient
+}
+
+type InstanceOperations interface {
+	List(opts *ListOpts) (*InstanceCollection, error)
+	Create(opts *Instance) (*Instance, error)
+	Update(existing *Instance, updates interface{}) (*Instance, error)
+	ById(id string) (*Instance, error)
+	Delete(container *Instance) error
+
+	ActionAllocate(*Instance) (*Instance, error)
+
+	ActionConsole(*Instance, *InstanceConsoleInput) (*InstanceConsole, error)
+
+	ActionCreate(*Instance) (*Instance, error)
+
+	ActionDeallocate(*Instance) (*Instance, error)
+
+	ActionError(*Instance) (*Instance, error)
+
+	ActionMigrate(*Instance) (*Instance, error)
+
+	ActionPurge(*Instance) (*Instance, error)
+
+	ActionRemove(*Instance) (*Instance, error)
+
+	ActionRestart(*Instance) (*Instance, error)
+
+	ActionStart(*Instance) (*Instance, error)
+
+	ActionStop(*Instance, *InstanceStop) (*Instance, error)
+
+	ActionUpdate(*Instance) (*Instance, error)
+
+	ActionUpdatehealthy(*Instance) (*Instance, error)
+
+	ActionUpdatereinitializing(*Instance) (*Instance, error)
+
+	ActionUpdateunhealthy(*Instance) (*Instance, error)
+}
+
+func newInstanceClient(rancherClient *RancherClient) *InstanceClient {
+	return &InstanceClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *InstanceClient) Create(container *Instance) (*Instance, error) {
+	resp := &Instance{}
+	err := c.rancherClient.doCreate(INSTANCE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *InstanceClient) Update(existing *Instance, updates interface{}) (*Instance, error) {
+	resp := &Instance{}
+	err := c.rancherClient.doUpdate(INSTANCE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *InstanceClient) List(opts *ListOpts) (*InstanceCollection, error) {
+	resp := &InstanceCollection{}
+	err := c.rancherClient.doList(INSTANCE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *InstanceCollection) Next() (*InstanceCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &InstanceCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *InstanceClient) ById(id string) (*Instance, error) {
+	resp := &Instance{}
+	err := c.rancherClient.doById(INSTANCE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *InstanceClient) Delete(container *Instance) error {
+	return c.rancherClient.doResourceDelete(INSTANCE_TYPE, &container.Resource)
+}
+
+func (c *InstanceClient) ActionAllocate(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "allocate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionConsole(resource *Instance, input *InstanceConsoleInput) (*InstanceConsole, error) {
+
+	resp := &InstanceConsole{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "console", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionCreate(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionDeallocate(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "deallocate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionError(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionMigrate(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "migrate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionPurge(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionRemove(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionRestart(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "restart", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionStart(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "start", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionStop(resource *Instance, input *InstanceStop) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "stop", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionUpdate(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionUpdatehealthy(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "updatehealthy", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionUpdatereinitializing(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "updatereinitializing", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceClient) ActionUpdateunhealthy(resource *Instance) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(INSTANCE_TYPE, "updateunhealthy", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_instance_console.go

@@ -0,0 +1,83 @@
+package client
+
+const (
+	INSTANCE_CONSOLE_TYPE = "instanceConsole"
+)
+
+type InstanceConsole struct {
+	Resource
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Password string `json:"password,omitempty" yaml:"password,omitempty"`
+
+	Url string `json:"url,omitempty" yaml:"url,omitempty"`
+}
+
+type InstanceConsoleCollection struct {
+	Collection
+	Data   []InstanceConsole `json:"data,omitempty"`
+	client *InstanceConsoleClient
+}
+
+type InstanceConsoleClient struct {
+	rancherClient *RancherClient
+}
+
+type InstanceConsoleOperations interface {
+	List(opts *ListOpts) (*InstanceConsoleCollection, error)
+	Create(opts *InstanceConsole) (*InstanceConsole, error)
+	Update(existing *InstanceConsole, updates interface{}) (*InstanceConsole, error)
+	ById(id string) (*InstanceConsole, error)
+	Delete(container *InstanceConsole) error
+}
+
+func newInstanceConsoleClient(rancherClient *RancherClient) *InstanceConsoleClient {
+	return &InstanceConsoleClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *InstanceConsoleClient) Create(container *InstanceConsole) (*InstanceConsole, error) {
+	resp := &InstanceConsole{}
+	err := c.rancherClient.doCreate(INSTANCE_CONSOLE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *InstanceConsoleClient) Update(existing *InstanceConsole, updates interface{}) (*InstanceConsole, error) {
+	resp := &InstanceConsole{}
+	err := c.rancherClient.doUpdate(INSTANCE_CONSOLE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *InstanceConsoleClient) List(opts *ListOpts) (*InstanceConsoleCollection, error) {
+	resp := &InstanceConsoleCollection{}
+	err := c.rancherClient.doList(INSTANCE_CONSOLE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *InstanceConsoleCollection) Next() (*InstanceConsoleCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &InstanceConsoleCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *InstanceConsoleClient) ById(id string) (*InstanceConsole, error) {
+	resp := &InstanceConsole{}
+	err := c.rancherClient.doById(INSTANCE_CONSOLE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *InstanceConsoleClient) Delete(container *InstanceConsole) error {
+	return c.rancherClient.doResourceDelete(INSTANCE_CONSOLE_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_instance_console_input.go

@@ -0,0 +1,77 @@
+package client
+
+const (
+	INSTANCE_CONSOLE_INPUT_TYPE = "instanceConsoleInput"
+)
+
+type InstanceConsoleInput struct {
+	Resource
+}
+
+type InstanceConsoleInputCollection struct {
+	Collection
+	Data   []InstanceConsoleInput `json:"data,omitempty"`
+	client *InstanceConsoleInputClient
+}
+
+type InstanceConsoleInputClient struct {
+	rancherClient *RancherClient
+}
+
+type InstanceConsoleInputOperations interface {
+	List(opts *ListOpts) (*InstanceConsoleInputCollection, error)
+	Create(opts *InstanceConsoleInput) (*InstanceConsoleInput, error)
+	Update(existing *InstanceConsoleInput, updates interface{}) (*InstanceConsoleInput, error)
+	ById(id string) (*InstanceConsoleInput, error)
+	Delete(container *InstanceConsoleInput) error
+}
+
+func newInstanceConsoleInputClient(rancherClient *RancherClient) *InstanceConsoleInputClient {
+	return &InstanceConsoleInputClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *InstanceConsoleInputClient) Create(container *InstanceConsoleInput) (*InstanceConsoleInput, error) {
+	resp := &InstanceConsoleInput{}
+	err := c.rancherClient.doCreate(INSTANCE_CONSOLE_INPUT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *InstanceConsoleInputClient) Update(existing *InstanceConsoleInput, updates interface{}) (*InstanceConsoleInput, error) {
+	resp := &InstanceConsoleInput{}
+	err := c.rancherClient.doUpdate(INSTANCE_CONSOLE_INPUT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *InstanceConsoleInputClient) List(opts *ListOpts) (*InstanceConsoleInputCollection, error) {
+	resp := &InstanceConsoleInputCollection{}
+	err := c.rancherClient.doList(INSTANCE_CONSOLE_INPUT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *InstanceConsoleInputCollection) Next() (*InstanceConsoleInputCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &InstanceConsoleInputCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *InstanceConsoleInputClient) ById(id string) (*InstanceConsoleInput, error) {
+	resp := &InstanceConsoleInput{}
+	err := c.rancherClient.doById(INSTANCE_CONSOLE_INPUT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *InstanceConsoleInputClient) Delete(container *InstanceConsoleInput) error {
+	return c.rancherClient.doResourceDelete(INSTANCE_CONSOLE_INPUT_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_instance_health_check.go

@@ -0,0 +1,99 @@
+package client
+
+const (
+	INSTANCE_HEALTH_CHECK_TYPE = "instanceHealthCheck"
+)
+
+type InstanceHealthCheck struct {
+	Resource
+
+	HealthyThreshold int64 `json:"healthyThreshold,omitempty" yaml:"healthy_threshold,omitempty"`
+
+	InitializingTimeout int64 `json:"initializingTimeout,omitempty" yaml:"initializing_timeout,omitempty"`
+
+	Interval int64 `json:"interval,omitempty" yaml:"interval,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Port int64 `json:"port,omitempty" yaml:"port,omitempty"`
+
+	RecreateOnQuorumStrategyConfig *RecreateOnQuorumStrategyConfig `json:"recreateOnQuorumStrategyConfig,omitempty" yaml:"recreate_on_quorum_strategy_config,omitempty"`
+
+	ReinitializingTimeout int64 `json:"reinitializingTimeout,omitempty" yaml:"reinitializing_timeout,omitempty"`
+
+	RequestLine string `json:"requestLine,omitempty" yaml:"request_line,omitempty"`
+
+	ResponseTimeout int64 `json:"responseTimeout,omitempty" yaml:"response_timeout,omitempty"`
+
+	Strategy string `json:"strategy,omitempty" yaml:"strategy,omitempty"`
+
+	UnhealthyThreshold int64 `json:"unhealthyThreshold,omitempty" yaml:"unhealthy_threshold,omitempty"`
+}
+
+type InstanceHealthCheckCollection struct {
+	Collection
+	Data   []InstanceHealthCheck `json:"data,omitempty"`
+	client *InstanceHealthCheckClient
+}
+
+type InstanceHealthCheckClient struct {
+	rancherClient *RancherClient
+}
+
+type InstanceHealthCheckOperations interface {
+	List(opts *ListOpts) (*InstanceHealthCheckCollection, error)
+	Create(opts *InstanceHealthCheck) (*InstanceHealthCheck, error)
+	Update(existing *InstanceHealthCheck, updates interface{}) (*InstanceHealthCheck, error)
+	ById(id string) (*InstanceHealthCheck, error)
+	Delete(container *InstanceHealthCheck) error
+}
+
+func newInstanceHealthCheckClient(rancherClient *RancherClient) *InstanceHealthCheckClient {
+	return &InstanceHealthCheckClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *InstanceHealthCheckClient) Create(container *InstanceHealthCheck) (*InstanceHealthCheck, error) {
+	resp := &InstanceHealthCheck{}
+	err := c.rancherClient.doCreate(INSTANCE_HEALTH_CHECK_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *InstanceHealthCheckClient) Update(existing *InstanceHealthCheck, updates interface{}) (*InstanceHealthCheck, error) {
+	resp := &InstanceHealthCheck{}
+	err := c.rancherClient.doUpdate(INSTANCE_HEALTH_CHECK_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *InstanceHealthCheckClient) List(opts *ListOpts) (*InstanceHealthCheckCollection, error) {
+	resp := &InstanceHealthCheckCollection{}
+	err := c.rancherClient.doList(INSTANCE_HEALTH_CHECK_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *InstanceHealthCheckCollection) Next() (*InstanceHealthCheckCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &InstanceHealthCheckCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *InstanceHealthCheckClient) ById(id string) (*InstanceHealthCheck, error) {
+	resp := &InstanceHealthCheck{}
+	err := c.rancherClient.doById(INSTANCE_HEALTH_CHECK_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *InstanceHealthCheckClient) Delete(container *InstanceHealthCheck) error {
+	return c.rancherClient.doResourceDelete(INSTANCE_HEALTH_CHECK_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_instance_link.go

@@ -0,0 +1,177 @@
+package client
+
+const (
+	INSTANCE_LINK_TYPE = "instanceLink"
+)
+
+type InstanceLink struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	InstanceId string `json:"instanceId,omitempty" yaml:"instance_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	LinkName string `json:"linkName,omitempty" yaml:"link_name,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Ports []interface{} `json:"ports,omitempty" yaml:"ports,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	TargetInstanceId string `json:"targetInstanceId,omitempty" yaml:"target_instance_id,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type InstanceLinkCollection struct {
+	Collection
+	Data   []InstanceLink `json:"data,omitempty"`
+	client *InstanceLinkClient
+}
+
+type InstanceLinkClient struct {
+	rancherClient *RancherClient
+}
+
+type InstanceLinkOperations interface {
+	List(opts *ListOpts) (*InstanceLinkCollection, error)
+	Create(opts *InstanceLink) (*InstanceLink, error)
+	Update(existing *InstanceLink, updates interface{}) (*InstanceLink, error)
+	ById(id string) (*InstanceLink, error)
+	Delete(container *InstanceLink) error
+
+	ActionActivate(*InstanceLink) (*InstanceLink, error)
+
+	ActionCreate(*InstanceLink) (*InstanceLink, error)
+
+	ActionDeactivate(*InstanceLink) (*InstanceLink, error)
+
+	ActionPurge(*InstanceLink) (*InstanceLink, error)
+
+	ActionRemove(*InstanceLink) (*InstanceLink, error)
+
+	ActionUpdate(*InstanceLink) (*InstanceLink, error)
+}
+
+func newInstanceLinkClient(rancherClient *RancherClient) *InstanceLinkClient {
+	return &InstanceLinkClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *InstanceLinkClient) Create(container *InstanceLink) (*InstanceLink, error) {
+	resp := &InstanceLink{}
+	err := c.rancherClient.doCreate(INSTANCE_LINK_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *InstanceLinkClient) Update(existing *InstanceLink, updates interface{}) (*InstanceLink, error) {
+	resp := &InstanceLink{}
+	err := c.rancherClient.doUpdate(INSTANCE_LINK_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *InstanceLinkClient) List(opts *ListOpts) (*InstanceLinkCollection, error) {
+	resp := &InstanceLinkCollection{}
+	err := c.rancherClient.doList(INSTANCE_LINK_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *InstanceLinkCollection) Next() (*InstanceLinkCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &InstanceLinkCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *InstanceLinkClient) ById(id string) (*InstanceLink, error) {
+	resp := &InstanceLink{}
+	err := c.rancherClient.doById(INSTANCE_LINK_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *InstanceLinkClient) Delete(container *InstanceLink) error {
+	return c.rancherClient.doResourceDelete(INSTANCE_LINK_TYPE, &container.Resource)
+}
+
+func (c *InstanceLinkClient) ActionActivate(resource *InstanceLink) (*InstanceLink, error) {
+
+	resp := &InstanceLink{}
+
+	err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceLinkClient) ActionCreate(resource *InstanceLink) (*InstanceLink, error) {
+
+	resp := &InstanceLink{}
+
+	err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceLinkClient) ActionDeactivate(resource *InstanceLink) (*InstanceLink, error) {
+
+	resp := &InstanceLink{}
+
+	err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceLinkClient) ActionPurge(resource *InstanceLink) (*InstanceLink, error) {
+
+	resp := &InstanceLink{}
+
+	err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceLinkClient) ActionRemove(resource *InstanceLink) (*InstanceLink, error) {
+
+	resp := &InstanceLink{}
+
+	err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *InstanceLinkClient) ActionUpdate(resource *InstanceLink) (*InstanceLink, error) {
+
+	resp := &InstanceLink{}
+
+	err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_instance_stop.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	INSTANCE_STOP_TYPE = "instanceStop"
+)
+
+type InstanceStop struct {
+	Resource
+
+	Remove bool `json:"remove,omitempty" yaml:"remove,omitempty"`
+
+	Timeout int64 `json:"timeout,omitempty" yaml:"timeout,omitempty"`
+}
+
+type InstanceStopCollection struct {
+	Collection
+	Data   []InstanceStop `json:"data,omitempty"`
+	client *InstanceStopClient
+}
+
+type InstanceStopClient struct {
+	rancherClient *RancherClient
+}
+
+type InstanceStopOperations interface {
+	List(opts *ListOpts) (*InstanceStopCollection, error)
+	Create(opts *InstanceStop) (*InstanceStop, error)
+	Update(existing *InstanceStop, updates interface{}) (*InstanceStop, error)
+	ById(id string) (*InstanceStop, error)
+	Delete(container *InstanceStop) error
+}
+
+func newInstanceStopClient(rancherClient *RancherClient) *InstanceStopClient {
+	return &InstanceStopClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *InstanceStopClient) Create(container *InstanceStop) (*InstanceStop, error) {
+	resp := &InstanceStop{}
+	err := c.rancherClient.doCreate(INSTANCE_STOP_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *InstanceStopClient) Update(existing *InstanceStop, updates interface{}) (*InstanceStop, error) {
+	resp := &InstanceStop{}
+	err := c.rancherClient.doUpdate(INSTANCE_STOP_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *InstanceStopClient) List(opts *ListOpts) (*InstanceStopCollection, error) {
+	resp := &InstanceStopCollection{}
+	err := c.rancherClient.doList(INSTANCE_STOP_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *InstanceStopCollection) Next() (*InstanceStopCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &InstanceStopCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *InstanceStopClient) ById(id string) (*InstanceStop, error) {
+	resp := &InstanceStop{}
+	err := c.rancherClient.doById(INSTANCE_STOP_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *InstanceStopClient) Delete(container *InstanceStop) error {
+	return c.rancherClient.doResourceDelete(INSTANCE_STOP_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_ip_address.go

@@ -0,0 +1,195 @@
+package client
+
+const (
+	IP_ADDRESS_TYPE = "ipAddress"
+)
+
+type IpAddress struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Address string `json:"address,omitempty" yaml:"address,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	NetworkId string `json:"networkId,omitempty" yaml:"network_id,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type IpAddressCollection struct {
+	Collection
+	Data   []IpAddress `json:"data,omitempty"`
+	client *IpAddressClient
+}
+
+type IpAddressClient struct {
+	rancherClient *RancherClient
+}
+
+type IpAddressOperations interface {
+	List(opts *ListOpts) (*IpAddressCollection, error)
+	Create(opts *IpAddress) (*IpAddress, error)
+	Update(existing *IpAddress, updates interface{}) (*IpAddress, error)
+	ById(id string) (*IpAddress, error)
+	Delete(container *IpAddress) error
+
+	ActionActivate(*IpAddress) (*IpAddress, error)
+
+	ActionAssociate(*IpAddress) (*IpAddress, error)
+
+	ActionCreate(*IpAddress) (*IpAddress, error)
+
+	ActionDeactivate(*IpAddress) (*IpAddress, error)
+
+	ActionDisassociate(*IpAddress) (*IpAddress, error)
+
+	ActionPurge(*IpAddress) (*IpAddress, error)
+
+	ActionRemove(*IpAddress) (*IpAddress, error)
+
+	ActionUpdate(*IpAddress) (*IpAddress, error)
+}
+
+func newIpAddressClient(rancherClient *RancherClient) *IpAddressClient {
+	return &IpAddressClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *IpAddressClient) Create(container *IpAddress) (*IpAddress, error) {
+	resp := &IpAddress{}
+	err := c.rancherClient.doCreate(IP_ADDRESS_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *IpAddressClient) Update(existing *IpAddress, updates interface{}) (*IpAddress, error) {
+	resp := &IpAddress{}
+	err := c.rancherClient.doUpdate(IP_ADDRESS_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *IpAddressClient) List(opts *ListOpts) (*IpAddressCollection, error) {
+	resp := &IpAddressCollection{}
+	err := c.rancherClient.doList(IP_ADDRESS_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *IpAddressCollection) Next() (*IpAddressCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &IpAddressCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *IpAddressClient) ById(id string) (*IpAddress, error) {
+	resp := &IpAddress{}
+	err := c.rancherClient.doById(IP_ADDRESS_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *IpAddressClient) Delete(container *IpAddress) error {
+	return c.rancherClient.doResourceDelete(IP_ADDRESS_TYPE, &container.Resource)
+}
+
+func (c *IpAddressClient) ActionActivate(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *IpAddressClient) ActionAssociate(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "associate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *IpAddressClient) ActionCreate(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *IpAddressClient) ActionDeactivate(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *IpAddressClient) ActionDisassociate(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "disassociate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *IpAddressClient) ActionPurge(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *IpAddressClient) ActionRemove(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *IpAddressClient) ActionUpdate(resource *IpAddress) (*IpAddress, error) {
+
+	resp := &IpAddress{}
+
+	err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_kubernetes_service.go

@@ -0,0 +1,275 @@
+package client
+
+const (
+	KUBERNETES_SERVICE_TYPE = "kubernetesService"
+)
+
+type KubernetesService struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	InstanceIds []string `json:"instanceIds,omitempty" yaml:"instance_ids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	LinkedServices map[string]interface{} `json:"linkedServices,omitempty" yaml:"linked_services,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	SelectorContainer string `json:"selectorContainer,omitempty" yaml:"selector_container,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Template interface{} `json:"template,omitempty" yaml:"template,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Vip string `json:"vip,omitempty" yaml:"vip,omitempty"`
+}
+
+type KubernetesServiceCollection struct {
+	Collection
+	Data   []KubernetesService `json:"data,omitempty"`
+	client *KubernetesServiceClient
+}
+
+type KubernetesServiceClient struct {
+	rancherClient *RancherClient
+}
+
+type KubernetesServiceOperations interface {
+	List(opts *ListOpts) (*KubernetesServiceCollection, error)
+	Create(opts *KubernetesService) (*KubernetesService, error)
+	Update(existing *KubernetesService, updates interface{}) (*KubernetesService, error)
+	ById(id string) (*KubernetesService, error)
+	Delete(container *KubernetesService) error
+
+	ActionActivate(*KubernetesService) (*Service, error)
+
+	ActionAddservicelink(*KubernetesService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionCancelupgrade(*KubernetesService) (*Service, error)
+
+	ActionContinueupgrade(*KubernetesService) (*Service, error)
+
+	ActionCreate(*KubernetesService) (*Service, error)
+
+	ActionDeactivate(*KubernetesService) (*Service, error)
+
+	ActionFinishupgrade(*KubernetesService) (*Service, error)
+
+	ActionRemove(*KubernetesService) (*Service, error)
+
+	ActionRemoveservicelink(*KubernetesService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionRestart(*KubernetesService, *ServiceRestart) (*Service, error)
+
+	ActionRollback(*KubernetesService) (*Service, error)
+
+	ActionSetservicelinks(*KubernetesService, *SetServiceLinksInput) (*Service, error)
+
+	ActionUpdate(*KubernetesService) (*Service, error)
+
+	ActionUpgrade(*KubernetesService, *ServiceUpgrade) (*Service, error)
+}
+
+func newKubernetesServiceClient(rancherClient *RancherClient) *KubernetesServiceClient {
+	return &KubernetesServiceClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *KubernetesServiceClient) Create(container *KubernetesService) (*KubernetesService, error) {
+	resp := &KubernetesService{}
+	err := c.rancherClient.doCreate(KUBERNETES_SERVICE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) Update(existing *KubernetesService, updates interface{}) (*KubernetesService, error) {
+	resp := &KubernetesService{}
+	err := c.rancherClient.doUpdate(KUBERNETES_SERVICE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) List(opts *ListOpts) (*KubernetesServiceCollection, error) {
+	resp := &KubernetesServiceCollection{}
+	err := c.rancherClient.doList(KUBERNETES_SERVICE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *KubernetesServiceCollection) Next() (*KubernetesServiceCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &KubernetesServiceCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *KubernetesServiceClient) ById(id string) (*KubernetesService, error) {
+	resp := &KubernetesService{}
+	err := c.rancherClient.doById(KUBERNETES_SERVICE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) Delete(container *KubernetesService) error {
+	return c.rancherClient.doResourceDelete(KUBERNETES_SERVICE_TYPE, &container.Resource)
+}
+
+func (c *KubernetesServiceClient) ActionActivate(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionAddservicelink(resource *KubernetesService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "addservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionCancelupgrade(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionContinueupgrade(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "continueupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionCreate(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionDeactivate(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionFinishupgrade(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionRemove(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionRemoveservicelink(resource *KubernetesService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "removeservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionRestart(resource *KubernetesService, input *ServiceRestart) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionRollback(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionSetservicelinks(resource *KubernetesService, input *SetServiceLinksInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "setservicelinks", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionUpdate(resource *KubernetesService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesServiceClient) ActionUpgrade(resource *KubernetesService, input *ServiceUpgrade) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_kubernetes_stack.go

@@ -0,0 +1,204 @@
+package client
+
+const (
+	KUBERNETES_STACK_TYPE = "kubernetesStack"
+)
+
+type KubernetesStack struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Answers map[string]interface{} `json:"answers,omitempty" yaml:"answers,omitempty"`
+
+	Binding *Binding `json:"binding,omitempty" yaml:"binding,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Group string `json:"group,omitempty" yaml:"group,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty"`
+
+	PreviousEnvironment map[string]interface{} `json:"previousEnvironment,omitempty" yaml:"previous_environment,omitempty"`
+
+	PreviousExternalId string `json:"previousExternalId,omitempty" yaml:"previous_external_id,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	ServiceIds []string `json:"serviceIds,omitempty" yaml:"service_ids,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Templates map[string]interface{} `json:"templates,omitempty" yaml:"templates,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type KubernetesStackCollection struct {
+	Collection
+	Data   []KubernetesStack `json:"data,omitempty"`
+	client *KubernetesStackClient
+}
+
+type KubernetesStackClient struct {
+	rancherClient *RancherClient
+}
+
+type KubernetesStackOperations interface {
+	List(opts *ListOpts) (*KubernetesStackCollection, error)
+	Create(opts *KubernetesStack) (*KubernetesStack, error)
+	Update(existing *KubernetesStack, updates interface{}) (*KubernetesStack, error)
+	ById(id string) (*KubernetesStack, error)
+	Delete(container *KubernetesStack) error
+
+	ActionCancelupgrade(*KubernetesStack) (*Stack, error)
+
+	ActionCreate(*KubernetesStack) (*Stack, error)
+
+	ActionError(*KubernetesStack) (*Stack, error)
+
+	ActionFinishupgrade(*KubernetesStack) (*Stack, error)
+
+	ActionRemove(*KubernetesStack) (*Stack, error)
+
+	ActionRollback(*KubernetesStack) (*Stack, error)
+
+	ActionUpgrade(*KubernetesStack, *KubernetesStackUpgrade) (*KubernetesStack, error)
+}
+
+func newKubernetesStackClient(rancherClient *RancherClient) *KubernetesStackClient {
+	return &KubernetesStackClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *KubernetesStackClient) Create(container *KubernetesStack) (*KubernetesStack, error) {
+	resp := &KubernetesStack{}
+	err := c.rancherClient.doCreate(KUBERNETES_STACK_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *KubernetesStackClient) Update(existing *KubernetesStack, updates interface{}) (*KubernetesStack, error) {
+	resp := &KubernetesStack{}
+	err := c.rancherClient.doUpdate(KUBERNETES_STACK_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *KubernetesStackClient) List(opts *ListOpts) (*KubernetesStackCollection, error) {
+	resp := &KubernetesStackCollection{}
+	err := c.rancherClient.doList(KUBERNETES_STACK_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *KubernetesStackCollection) Next() (*KubernetesStackCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &KubernetesStackCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *KubernetesStackClient) ById(id string) (*KubernetesStack, error) {
+	resp := &KubernetesStack{}
+	err := c.rancherClient.doById(KUBERNETES_STACK_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *KubernetesStackClient) Delete(container *KubernetesStack) error {
+	return c.rancherClient.doResourceDelete(KUBERNETES_STACK_TYPE, &container.Resource)
+}
+
+func (c *KubernetesStackClient) ActionCancelupgrade(resource *KubernetesStack) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesStackClient) ActionCreate(resource *KubernetesStack) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesStackClient) ActionError(resource *KubernetesStack) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesStackClient) ActionFinishupgrade(resource *KubernetesStack) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesStackClient) ActionRemove(resource *KubernetesStack) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesStackClient) ActionRollback(resource *KubernetesStack) (*Stack, error) {
+
+	resp := &Stack{}
+
+	err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *KubernetesStackClient) ActionUpgrade(resource *KubernetesStack, input *KubernetesStackUpgrade) (*KubernetesStack, error) {
+
+	resp := &KubernetesStack{}
+
+	err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "upgrade", &resource.Resource, input, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_kubernetes_stack_upgrade.go

@@ -0,0 +1,85 @@
+package client
+
+const (
+	KUBERNETES_STACK_UPGRADE_TYPE = "kubernetesStackUpgrade"
+)
+
+type KubernetesStackUpgrade struct {
+	Resource
+
+	Answers map[string]interface{} `json:"answers,omitempty" yaml:"answers,omitempty"`
+
+	Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Templates map[string]interface{} `json:"templates,omitempty" yaml:"templates,omitempty"`
+}
+
+type KubernetesStackUpgradeCollection struct {
+	Collection
+	Data   []KubernetesStackUpgrade `json:"data,omitempty"`
+	client *KubernetesStackUpgradeClient
+}
+
+type KubernetesStackUpgradeClient struct {
+	rancherClient *RancherClient
+}
+
+type KubernetesStackUpgradeOperations interface {
+	List(opts *ListOpts) (*KubernetesStackUpgradeCollection, error)
+	Create(opts *KubernetesStackUpgrade) (*KubernetesStackUpgrade, error)
+	Update(existing *KubernetesStackUpgrade, updates interface{}) (*KubernetesStackUpgrade, error)
+	ById(id string) (*KubernetesStackUpgrade, error)
+	Delete(container *KubernetesStackUpgrade) error
+}
+
+func newKubernetesStackUpgradeClient(rancherClient *RancherClient) *KubernetesStackUpgradeClient {
+	return &KubernetesStackUpgradeClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *KubernetesStackUpgradeClient) Create(container *KubernetesStackUpgrade) (*KubernetesStackUpgrade, error) {
+	resp := &KubernetesStackUpgrade{}
+	err := c.rancherClient.doCreate(KUBERNETES_STACK_UPGRADE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *KubernetesStackUpgradeClient) Update(existing *KubernetesStackUpgrade, updates interface{}) (*KubernetesStackUpgrade, error) {
+	resp := &KubernetesStackUpgrade{}
+	err := c.rancherClient.doUpdate(KUBERNETES_STACK_UPGRADE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *KubernetesStackUpgradeClient) List(opts *ListOpts) (*KubernetesStackUpgradeCollection, error) {
+	resp := &KubernetesStackUpgradeCollection{}
+	err := c.rancherClient.doList(KUBERNETES_STACK_UPGRADE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *KubernetesStackUpgradeCollection) Next() (*KubernetesStackUpgradeCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &KubernetesStackUpgradeCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *KubernetesStackUpgradeClient) ById(id string) (*KubernetesStackUpgrade, error) {
+	resp := &KubernetesStackUpgrade{}
+	err := c.rancherClient.doById(KUBERNETES_STACK_UPGRADE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *KubernetesStackUpgradeClient) Delete(container *KubernetesStackUpgrade) error {
+	return c.rancherClient.doResourceDelete(KUBERNETES_STACK_UPGRADE_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_label.go

@@ -0,0 +1,129 @@
+package client
+
+const (
+	LABEL_TYPE = "label"
+)
+
+type Label struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Key string `json:"key,omitempty" yaml:"key,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Value string `json:"value,omitempty" yaml:"value,omitempty"`
+}
+
+type LabelCollection struct {
+	Collection
+	Data   []Label `json:"data,omitempty"`
+	client *LabelClient
+}
+
+type LabelClient struct {
+	rancherClient *RancherClient
+}
+
+type LabelOperations interface {
+	List(opts *ListOpts) (*LabelCollection, error)
+	Create(opts *Label) (*Label, error)
+	Update(existing *Label, updates interface{}) (*Label, error)
+	ById(id string) (*Label, error)
+	Delete(container *Label) error
+
+	ActionCreate(*Label) (*Label, error)
+
+	ActionRemove(*Label) (*Label, error)
+}
+
+func newLabelClient(rancherClient *RancherClient) *LabelClient {
+	return &LabelClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LabelClient) Create(container *Label) (*Label, error) {
+	resp := &Label{}
+	err := c.rancherClient.doCreate(LABEL_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LabelClient) Update(existing *Label, updates interface{}) (*Label, error) {
+	resp := &Label{}
+	err := c.rancherClient.doUpdate(LABEL_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LabelClient) List(opts *ListOpts) (*LabelCollection, error) {
+	resp := &LabelCollection{}
+	err := c.rancherClient.doList(LABEL_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LabelCollection) Next() (*LabelCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LabelCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LabelClient) ById(id string) (*Label, error) {
+	resp := &Label{}
+	err := c.rancherClient.doById(LABEL_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LabelClient) Delete(container *Label) error {
+	return c.rancherClient.doResourceDelete(LABEL_TYPE, &container.Resource)
+}
+
+func (c *LabelClient) ActionCreate(resource *Label) (*Label, error) {
+
+	resp := &Label{}
+
+	err := c.rancherClient.doAction(LABEL_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LabelClient) ActionRemove(resource *Label) (*Label, error) {
+
+	resp := &Label{}
+
+	err := c.rancherClient.doAction(LABEL_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_launch_config.go

@@ -0,0 +1,518 @@
+package client
+
+const (
+	LAUNCH_CONFIG_TYPE = "launchConfig"
+)
+
+type LaunchConfig struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
+
+	AllocationState string `json:"allocationState,omitempty" yaml:"allocation_state,omitempty"`
+
+	BlkioDeviceOptions map[string]interface{} `json:"blkioDeviceOptions,omitempty" yaml:"blkio_device_options,omitempty"`
+
+	BlkioWeight int64 `json:"blkioWeight,omitempty" yaml:"blkio_weight,omitempty"`
+
+	Build *DockerBuild `json:"build,omitempty" yaml:"build,omitempty"`
+
+	CapAdd []string `json:"capAdd,omitempty" yaml:"cap_add,omitempty"`
+
+	CapDrop []string `json:"capDrop,omitempty" yaml:"cap_drop,omitempty"`
+
+	CgroupParent string `json:"cgroupParent,omitempty" yaml:"cgroup_parent,omitempty"`
+
+	Command []string `json:"command,omitempty" yaml:"command,omitempty"`
+
+	Count int64 `json:"count,omitempty" yaml:"count,omitempty"`
+
+	CpuCount int64 `json:"cpuCount,omitempty" yaml:"cpu_count,omitempty"`
+
+	CpuPercent int64 `json:"cpuPercent,omitempty" yaml:"cpu_percent,omitempty"`
+
+	CpuPeriod int64 `json:"cpuPeriod,omitempty" yaml:"cpu_period,omitempty"`
+
+	CpuQuota int64 `json:"cpuQuota,omitempty" yaml:"cpu_quota,omitempty"`
+
+	CpuRealtimePeriod int64 `json:"cpuRealtimePeriod,omitempty" yaml:"cpu_realtime_period,omitempty"`
+
+	CpuRealtimeRuntime int64 `json:"cpuRealtimeRuntime,omitempty" yaml:"cpu_realtime_runtime,omitempty"`
+
+	CpuSet string `json:"cpuSet,omitempty" yaml:"cpu_set,omitempty"`
+
+	CpuSetMems string `json:"cpuSetMems,omitempty" yaml:"cpu_set_mems,omitempty"`
+
+	CpuShares int64 `json:"cpuShares,omitempty" yaml:"cpu_shares,omitempty"`
+
+	CreateIndex int64 `json:"createIndex,omitempty" yaml:"create_index,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DataVolumeMounts map[string]interface{} `json:"dataVolumeMounts,omitempty" yaml:"data_volume_mounts,omitempty"`
+
+	DataVolumes []string `json:"dataVolumes,omitempty" yaml:"data_volumes,omitempty"`
+
+	DataVolumesFrom []string `json:"dataVolumesFrom,omitempty" yaml:"data_volumes_from,omitempty"`
+
+	DataVolumesFromLaunchConfigs []string `json:"dataVolumesFromLaunchConfigs,omitempty" yaml:"data_volumes_from_launch_configs,omitempty"`
+
+	DeploymentUnitUuid string `json:"deploymentUnitUuid,omitempty" yaml:"deployment_unit_uuid,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Devices []string `json:"devices,omitempty" yaml:"devices,omitempty"`
+
+	DiskQuota int64 `json:"diskQuota,omitempty" yaml:"disk_quota,omitempty"`
+
+	Disks []VirtualMachineDisk `json:"disks,omitempty" yaml:"disks,omitempty"`
+
+	Dns []string `json:"dns,omitempty" yaml:"dns,omitempty"`
+
+	DnsOpt []string `json:"dnsOpt,omitempty" yaml:"dns_opt,omitempty"`
+
+	DnsSearch []string `json:"dnsSearch,omitempty" yaml:"dns_search,omitempty"`
+
+	DomainName string `json:"domainName,omitempty" yaml:"domain_name,omitempty"`
+
+	DrainTimeoutMs int64 `json:"drainTimeoutMs,omitempty" yaml:"drain_timeout_ms,omitempty"`
+
+	EntryPoint []string `json:"entryPoint,omitempty" yaml:"entry_point,omitempty"`
+
+	Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
+
+	Expose []string `json:"expose,omitempty" yaml:"expose,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	ExtraHosts []string `json:"extraHosts,omitempty" yaml:"extra_hosts,omitempty"`
+
+	FirstRunning string `json:"firstRunning,omitempty" yaml:"first_running,omitempty"`
+
+	GroupAdd []string `json:"groupAdd,omitempty" yaml:"group_add,omitempty"`
+
+	HealthCheck *InstanceHealthCheck `json:"healthCheck,omitempty" yaml:"health_check,omitempty"`
+
+	HealthCmd []string `json:"healthCmd,omitempty" yaml:"health_cmd,omitempty"`
+
+	HealthInterval int64 `json:"healthInterval,omitempty" yaml:"health_interval,omitempty"`
+
+	HealthRetries int64 `json:"healthRetries,omitempty" yaml:"health_retries,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	HealthTimeout int64 `json:"healthTimeout,omitempty" yaml:"health_timeout,omitempty"`
+
+	HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
+
+	Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
+
+	ImageUuid string `json:"imageUuid,omitempty" yaml:"image_uuid,omitempty"`
+
+	InstanceLinks map[string]interface{} `json:"instanceLinks,omitempty" yaml:"instance_links,omitempty"`
+
+	InstanceTriggeredStop string `json:"instanceTriggeredStop,omitempty" yaml:"instance_triggered_stop,omitempty"`
+
+	IoMaximumBandwidth int64 `json:"ioMaximumBandwidth,omitempty" yaml:"io_maximum_bandwidth,omitempty"`
+
+	IoMaximumIOps int64 `json:"ioMaximumIOps,omitempty" yaml:"io_maximum_iops,omitempty"`
+
+	Ip string `json:"ip,omitempty" yaml:"ip,omitempty"`
+
+	Ip6 string `json:"ip6,omitempty" yaml:"ip6,omitempty"`
+
+	IpcMode string `json:"ipcMode,omitempty" yaml:"ipc_mode,omitempty"`
+
+	Isolation string `json:"isolation,omitempty" yaml:"isolation,omitempty"`
+
+	KernelMemory int64 `json:"kernelMemory,omitempty" yaml:"kernel_memory,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Labels map[string]interface{} `json:"labels,omitempty" yaml:"labels,omitempty"`
+
+	LogConfig *LogConfig `json:"logConfig,omitempty" yaml:"log_config,omitempty"`
+
+	LxcConf map[string]interface{} `json:"lxcConf,omitempty" yaml:"lxc_conf,omitempty"`
+
+	Memory int64 `json:"memory,omitempty" yaml:"memory,omitempty"`
+
+	MemoryMb int64 `json:"memoryMb,omitempty" yaml:"memory_mb,omitempty"`
+
+	MemoryReservation int64 `json:"memoryReservation,omitempty" yaml:"memory_reservation,omitempty"`
+
+	MemorySwap int64 `json:"memorySwap,omitempty" yaml:"memory_swap,omitempty"`
+
+	MemorySwappiness int64 `json:"memorySwappiness,omitempty" yaml:"memory_swappiness,omitempty"`
+
+	MilliCpuReservation int64 `json:"milliCpuReservation,omitempty" yaml:"milli_cpu_reservation,omitempty"`
+
+	Mounts []MountEntry `json:"mounts,omitempty" yaml:"mounts,omitempty"`
+
+	NativeContainer bool `json:"nativeContainer,omitempty" yaml:"native_container,omitempty"`
+
+	NetAlias []string `json:"netAlias,omitempty" yaml:"net_alias,omitempty"`
+
+	NetworkContainerId string `json:"networkContainerId,omitempty" yaml:"network_container_id,omitempty"`
+
+	NetworkIds []string `json:"networkIds,omitempty" yaml:"network_ids,omitempty"`
+
+	NetworkLaunchConfig string `json:"networkLaunchConfig,omitempty" yaml:"network_launch_config,omitempty"`
+
+	NetworkMode string `json:"networkMode,omitempty" yaml:"network_mode,omitempty"`
+
+	OomKillDisable bool `json:"oomKillDisable,omitempty" yaml:"oom_kill_disable,omitempty"`
+
+	OomScoreAdj int64 `json:"oomScoreAdj,omitempty" yaml:"oom_score_adj,omitempty"`
+
+	PidMode string `json:"pidMode,omitempty" yaml:"pid_mode,omitempty"`
+
+	PidsLimit int64 `json:"pidsLimit,omitempty" yaml:"pids_limit,omitempty"`
+
+	Ports []string `json:"ports,omitempty" yaml:"ports,omitempty"`
+
+	PrimaryIpAddress string `json:"primaryIpAddress,omitempty" yaml:"primary_ip_address,omitempty"`
+
+	PrimaryNetworkId string `json:"primaryNetworkId,omitempty" yaml:"primary_network_id,omitempty"`
+
+	Privileged bool `json:"privileged,omitempty" yaml:"privileged,omitempty"`
+
+	PublishAllPorts bool `json:"publishAllPorts,omitempty" yaml:"publish_all_ports,omitempty"`
+
+	ReadOnly bool `json:"readOnly,omitempty" yaml:"read_only,omitempty"`
+
+	RegistryCredentialId string `json:"registryCredentialId,omitempty" yaml:"registry_credential_id,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	RequestedHostId string `json:"requestedHostId,omitempty" yaml:"requested_host_id,omitempty"`
+
+	RequestedIpAddress string `json:"requestedIpAddress,omitempty" yaml:"requested_ip_address,omitempty"`
+
+	RunInit bool `json:"runInit,omitempty" yaml:"run_init,omitempty"`
+
+	Secrets []SecretReference `json:"secrets,omitempty" yaml:"secrets,omitempty"`
+
+	SecurityOpt []string `json:"securityOpt,omitempty" yaml:"security_opt,omitempty"`
+
+	ServiceId string `json:"serviceId,omitempty" yaml:"service_id,omitempty"`
+
+	ServiceIds []string `json:"serviceIds,omitempty" yaml:"service_ids,omitempty"`
+
+	ShmSize int64 `json:"shmSize,omitempty" yaml:"shm_size,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	StartCount int64 `json:"startCount,omitempty" yaml:"start_count,omitempty"`
+
+	StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	StdinOpen bool `json:"stdinOpen,omitempty" yaml:"stdin_open,omitempty"`
+
+	StopSignal string `json:"stopSignal,omitempty" yaml:"stop_signal,omitempty"`
+
+	StopTimeout int64 `json:"stopTimeout,omitempty" yaml:"stop_timeout,omitempty"`
+
+	StorageOpt map[string]interface{} `json:"storageOpt,omitempty" yaml:"storage_opt,omitempty"`
+
+	Sysctls map[string]interface{} `json:"sysctls,omitempty" yaml:"sysctls,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Tmpfs map[string]interface{} `json:"tmpfs,omitempty" yaml:"tmpfs,omitempty"`
+
+	Token string `json:"token,omitempty" yaml:"token,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Tty bool `json:"tty,omitempty" yaml:"tty,omitempty"`
+
+	Ulimits []Ulimit `json:"ulimits,omitempty" yaml:"ulimits,omitempty"`
+
+	User string `json:"user,omitempty" yaml:"user,omitempty"`
+
+	UserPorts []string `json:"userPorts,omitempty" yaml:"user_ports,omitempty"`
+
+	Userdata string `json:"userdata,omitempty" yaml:"userdata,omitempty"`
+
+	UsernsMode string `json:"usernsMode,omitempty" yaml:"userns_mode,omitempty"`
+
+	Uts string `json:"uts,omitempty" yaml:"uts,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Vcpu int64 `json:"vcpu,omitempty" yaml:"vcpu,omitempty"`
+
+	Version string `json:"version,omitempty" yaml:"version,omitempty"`
+
+	VolumeDriver string `json:"volumeDriver,omitempty" yaml:"volume_driver,omitempty"`
+
+	WorkingDir string `json:"workingDir,omitempty" yaml:"working_dir,omitempty"`
+}
+
+type LaunchConfigCollection struct {
+	Collection
+	Data   []LaunchConfig `json:"data,omitempty"`
+	client *LaunchConfigClient
+}
+
+type LaunchConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type LaunchConfigOperations interface {
+	List(opts *ListOpts) (*LaunchConfigCollection, error)
+	Create(opts *LaunchConfig) (*LaunchConfig, error)
+	Update(existing *LaunchConfig, updates interface{}) (*LaunchConfig, error)
+	ById(id string) (*LaunchConfig, error)
+	Delete(container *LaunchConfig) error
+
+	ActionAllocate(*LaunchConfig) (*Instance, error)
+
+	ActionConsole(*LaunchConfig, *InstanceConsoleInput) (*InstanceConsole, error)
+
+	ActionCreate(*LaunchConfig) (*Instance, error)
+
+	ActionDeallocate(*LaunchConfig) (*Instance, error)
+
+	ActionError(*LaunchConfig) (*Instance, error)
+
+	ActionExecute(*LaunchConfig, *ContainerExec) (*HostAccess, error)
+
+	ActionMigrate(*LaunchConfig) (*Instance, error)
+
+	ActionProxy(*LaunchConfig, *ContainerProxy) (*HostAccess, error)
+
+	ActionPurge(*LaunchConfig) (*Instance, error)
+
+	ActionRemove(*LaunchConfig) (*Instance, error)
+
+	ActionRestart(*LaunchConfig) (*Instance, error)
+
+	ActionStart(*LaunchConfig) (*Instance, error)
+
+	ActionStop(*LaunchConfig, *InstanceStop) (*Instance, error)
+
+	ActionUpdate(*LaunchConfig) (*Instance, error)
+
+	ActionUpdatehealthy(*LaunchConfig) (*Instance, error)
+
+	ActionUpdatereinitializing(*LaunchConfig) (*Instance, error)
+
+	ActionUpdateunhealthy(*LaunchConfig) (*Instance, error)
+}
+
+func newLaunchConfigClient(rancherClient *RancherClient) *LaunchConfigClient {
+	return &LaunchConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LaunchConfigClient) Create(container *LaunchConfig) (*LaunchConfig, error) {
+	resp := &LaunchConfig{}
+	err := c.rancherClient.doCreate(LAUNCH_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LaunchConfigClient) Update(existing *LaunchConfig, updates interface{}) (*LaunchConfig, error) {
+	resp := &LaunchConfig{}
+	err := c.rancherClient.doUpdate(LAUNCH_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LaunchConfigClient) List(opts *ListOpts) (*LaunchConfigCollection, error) {
+	resp := &LaunchConfigCollection{}
+	err := c.rancherClient.doList(LAUNCH_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LaunchConfigCollection) Next() (*LaunchConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LaunchConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LaunchConfigClient) ById(id string) (*LaunchConfig, error) {
+	resp := &LaunchConfig{}
+	err := c.rancherClient.doById(LAUNCH_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LaunchConfigClient) Delete(container *LaunchConfig) error {
+	return c.rancherClient.doResourceDelete(LAUNCH_CONFIG_TYPE, &container.Resource)
+}
+
+func (c *LaunchConfigClient) ActionAllocate(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "allocate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionConsole(resource *LaunchConfig, input *InstanceConsoleInput) (*InstanceConsole, error) {
+
+	resp := &InstanceConsole{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "console", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionCreate(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionDeallocate(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "deallocate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionError(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionExecute(resource *LaunchConfig, input *ContainerExec) (*HostAccess, error) {
+
+	resp := &HostAccess{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "execute", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionMigrate(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "migrate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionProxy(resource *LaunchConfig, input *ContainerProxy) (*HostAccess, error) {
+
+	resp := &HostAccess{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "proxy", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionPurge(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionRemove(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionRestart(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "restart", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionStart(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "start", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionStop(resource *LaunchConfig, input *InstanceStop) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "stop", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionUpdate(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionUpdatehealthy(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "updatehealthy", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionUpdatereinitializing(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "updatereinitializing", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LaunchConfigClient) ActionUpdateunhealthy(resource *LaunchConfig) (*Instance, error) {
+
+	resp := &Instance{}
+
+	err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "updateunhealthy", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_lb_config.go

@@ -0,0 +1,87 @@
+package client
+
+const (
+	LB_CONFIG_TYPE = "lbConfig"
+)
+
+type LbConfig struct {
+	Resource
+
+	CertificateIds []string `json:"certificateIds,omitempty" yaml:"certificate_ids,omitempty"`
+
+	Config string `json:"config,omitempty" yaml:"config,omitempty"`
+
+	DefaultCertificateId string `json:"defaultCertificateId,omitempty" yaml:"default_certificate_id,omitempty"`
+
+	PortRules []PortRule `json:"portRules,omitempty" yaml:"port_rules,omitempty"`
+
+	StickinessPolicy *LoadBalancerCookieStickinessPolicy `json:"stickinessPolicy,omitempty" yaml:"stickiness_policy,omitempty"`
+}
+
+type LbConfigCollection struct {
+	Collection
+	Data   []LbConfig `json:"data,omitempty"`
+	client *LbConfigClient
+}
+
+type LbConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type LbConfigOperations interface {
+	List(opts *ListOpts) (*LbConfigCollection, error)
+	Create(opts *LbConfig) (*LbConfig, error)
+	Update(existing *LbConfig, updates interface{}) (*LbConfig, error)
+	ById(id string) (*LbConfig, error)
+	Delete(container *LbConfig) error
+}
+
+func newLbConfigClient(rancherClient *RancherClient) *LbConfigClient {
+	return &LbConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LbConfigClient) Create(container *LbConfig) (*LbConfig, error) {
+	resp := &LbConfig{}
+	err := c.rancherClient.doCreate(LB_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LbConfigClient) Update(existing *LbConfig, updates interface{}) (*LbConfig, error) {
+	resp := &LbConfig{}
+	err := c.rancherClient.doUpdate(LB_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LbConfigClient) List(opts *ListOpts) (*LbConfigCollection, error) {
+	resp := &LbConfigCollection{}
+	err := c.rancherClient.doList(LB_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LbConfigCollection) Next() (*LbConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LbConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LbConfigClient) ById(id string) (*LbConfig, error) {
+	resp := &LbConfig{}
+	err := c.rancherClient.doById(LB_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LbConfigClient) Delete(container *LbConfig) error {
+	return c.rancherClient.doResourceDelete(LB_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_lb_target_config.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	LB_TARGET_CONFIG_TYPE = "lbTargetConfig"
+)
+
+type LbTargetConfig struct {
+	Resource
+
+	PortRules []TargetPortRule `json:"portRules,omitempty" yaml:"port_rules,omitempty"`
+}
+
+type LbTargetConfigCollection struct {
+	Collection
+	Data   []LbTargetConfig `json:"data,omitempty"`
+	client *LbTargetConfigClient
+}
+
+type LbTargetConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type LbTargetConfigOperations interface {
+	List(opts *ListOpts) (*LbTargetConfigCollection, error)
+	Create(opts *LbTargetConfig) (*LbTargetConfig, error)
+	Update(existing *LbTargetConfig, updates interface{}) (*LbTargetConfig, error)
+	ById(id string) (*LbTargetConfig, error)
+	Delete(container *LbTargetConfig) error
+}
+
+func newLbTargetConfigClient(rancherClient *RancherClient) *LbTargetConfigClient {
+	return &LbTargetConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LbTargetConfigClient) Create(container *LbTargetConfig) (*LbTargetConfig, error) {
+	resp := &LbTargetConfig{}
+	err := c.rancherClient.doCreate(LB_TARGET_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LbTargetConfigClient) Update(existing *LbTargetConfig, updates interface{}) (*LbTargetConfig, error) {
+	resp := &LbTargetConfig{}
+	err := c.rancherClient.doUpdate(LB_TARGET_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LbTargetConfigClient) List(opts *ListOpts) (*LbTargetConfigCollection, error) {
+	resp := &LbTargetConfigCollection{}
+	err := c.rancherClient.doList(LB_TARGET_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LbTargetConfigCollection) Next() (*LbTargetConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LbTargetConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LbTargetConfigClient) ById(id string) (*LbTargetConfig, error) {
+	resp := &LbTargetConfig{}
+	err := c.rancherClient.doById(LB_TARGET_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LbTargetConfigClient) Delete(container *LbTargetConfig) error {
+	return c.rancherClient.doResourceDelete(LB_TARGET_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_load_balancer_cookie_stickiness_policy.go

@@ -0,0 +1,91 @@
+package client
+
+const (
+	LOAD_BALANCER_COOKIE_STICKINESS_POLICY_TYPE = "loadBalancerCookieStickinessPolicy"
+)
+
+type LoadBalancerCookieStickinessPolicy struct {
+	Resource
+
+	Cookie string `json:"cookie,omitempty" yaml:"cookie,omitempty"`
+
+	Domain string `json:"domain,omitempty" yaml:"domain,omitempty"`
+
+	Indirect bool `json:"indirect,omitempty" yaml:"indirect,omitempty"`
+
+	Mode string `json:"mode,omitempty" yaml:"mode,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Nocache bool `json:"nocache,omitempty" yaml:"nocache,omitempty"`
+
+	Postonly bool `json:"postonly,omitempty" yaml:"postonly,omitempty"`
+}
+
+type LoadBalancerCookieStickinessPolicyCollection struct {
+	Collection
+	Data   []LoadBalancerCookieStickinessPolicy `json:"data,omitempty"`
+	client *LoadBalancerCookieStickinessPolicyClient
+}
+
+type LoadBalancerCookieStickinessPolicyClient struct {
+	rancherClient *RancherClient
+}
+
+type LoadBalancerCookieStickinessPolicyOperations interface {
+	List(opts *ListOpts) (*LoadBalancerCookieStickinessPolicyCollection, error)
+	Create(opts *LoadBalancerCookieStickinessPolicy) (*LoadBalancerCookieStickinessPolicy, error)
+	Update(existing *LoadBalancerCookieStickinessPolicy, updates interface{}) (*LoadBalancerCookieStickinessPolicy, error)
+	ById(id string) (*LoadBalancerCookieStickinessPolicy, error)
+	Delete(container *LoadBalancerCookieStickinessPolicy) error
+}
+
+func newLoadBalancerCookieStickinessPolicyClient(rancherClient *RancherClient) *LoadBalancerCookieStickinessPolicyClient {
+	return &LoadBalancerCookieStickinessPolicyClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LoadBalancerCookieStickinessPolicyClient) Create(container *LoadBalancerCookieStickinessPolicy) (*LoadBalancerCookieStickinessPolicy, error) {
+	resp := &LoadBalancerCookieStickinessPolicy{}
+	err := c.rancherClient.doCreate(LOAD_BALANCER_COOKIE_STICKINESS_POLICY_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LoadBalancerCookieStickinessPolicyClient) Update(existing *LoadBalancerCookieStickinessPolicy, updates interface{}) (*LoadBalancerCookieStickinessPolicy, error) {
+	resp := &LoadBalancerCookieStickinessPolicy{}
+	err := c.rancherClient.doUpdate(LOAD_BALANCER_COOKIE_STICKINESS_POLICY_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LoadBalancerCookieStickinessPolicyClient) List(opts *ListOpts) (*LoadBalancerCookieStickinessPolicyCollection, error) {
+	resp := &LoadBalancerCookieStickinessPolicyCollection{}
+	err := c.rancherClient.doList(LOAD_BALANCER_COOKIE_STICKINESS_POLICY_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LoadBalancerCookieStickinessPolicyCollection) Next() (*LoadBalancerCookieStickinessPolicyCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LoadBalancerCookieStickinessPolicyCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LoadBalancerCookieStickinessPolicyClient) ById(id string) (*LoadBalancerCookieStickinessPolicy, error) {
+	resp := &LoadBalancerCookieStickinessPolicy{}
+	err := c.rancherClient.doById(LOAD_BALANCER_COOKIE_STICKINESS_POLICY_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LoadBalancerCookieStickinessPolicyClient) Delete(container *LoadBalancerCookieStickinessPolicy) error {
+	return c.rancherClient.doResourceDelete(LOAD_BALANCER_COOKIE_STICKINESS_POLICY_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_load_balancer_service.go

@@ -0,0 +1,297 @@
+package client
+
+const (
+	LOAD_BALANCER_SERVICE_TYPE = "loadBalancerService"
+)
+
+type LoadBalancerService struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AssignServiceIpAddress bool `json:"assignServiceIpAddress,omitempty" yaml:"assign_service_ip_address,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	CurrentScale int64 `json:"currentScale,omitempty" yaml:"current_scale,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	InstanceIds []string `json:"instanceIds,omitempty" yaml:"instance_ids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
+
+	LbConfig *LbConfig `json:"lbConfig,omitempty" yaml:"lb_config,omitempty"`
+
+	LinkedServices map[string]interface{} `json:"linkedServices,omitempty" yaml:"linked_services,omitempty"`
+
+	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PublicEndpoints []PublicEndpoint `json:"publicEndpoints,omitempty" yaml:"public_endpoints,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	RetainIp bool `json:"retainIp,omitempty" yaml:"retain_ip,omitempty"`
+
+	Scale int64 `json:"scale,omitempty" yaml:"scale,omitempty"`
+
+	ScalePolicy *ScalePolicy `json:"scalePolicy,omitempty" yaml:"scale_policy,omitempty"`
+
+	SelectorLink string `json:"selectorLink,omitempty" yaml:"selector_link,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Upgrade *ServiceUpgrade `json:"upgrade,omitempty" yaml:"upgrade,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Vip string `json:"vip,omitempty" yaml:"vip,omitempty"`
+}
+
+type LoadBalancerServiceCollection struct {
+	Collection
+	Data   []LoadBalancerService `json:"data,omitempty"`
+	client *LoadBalancerServiceClient
+}
+
+type LoadBalancerServiceClient struct {
+	rancherClient *RancherClient
+}
+
+type LoadBalancerServiceOperations interface {
+	List(opts *ListOpts) (*LoadBalancerServiceCollection, error)
+	Create(opts *LoadBalancerService) (*LoadBalancerService, error)
+	Update(existing *LoadBalancerService, updates interface{}) (*LoadBalancerService, error)
+	ById(id string) (*LoadBalancerService, error)
+	Delete(container *LoadBalancerService) error
+
+	ActionActivate(*LoadBalancerService) (*Service, error)
+
+	ActionAddservicelink(*LoadBalancerService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionCancelupgrade(*LoadBalancerService) (*Service, error)
+
+	ActionContinueupgrade(*LoadBalancerService) (*Service, error)
+
+	ActionCreate(*LoadBalancerService) (*Service, error)
+
+	ActionDeactivate(*LoadBalancerService) (*Service, error)
+
+	ActionFinishupgrade(*LoadBalancerService) (*Service, error)
+
+	ActionRemove(*LoadBalancerService) (*Service, error)
+
+	ActionRemoveservicelink(*LoadBalancerService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionRestart(*LoadBalancerService, *ServiceRestart) (*Service, error)
+
+	ActionRollback(*LoadBalancerService) (*Service, error)
+
+	ActionSetservicelinks(*LoadBalancerService, *SetServiceLinksInput) (*Service, error)
+
+	ActionUpdate(*LoadBalancerService) (*Service, error)
+
+	ActionUpgrade(*LoadBalancerService, *ServiceUpgrade) (*Service, error)
+}
+
+func newLoadBalancerServiceClient(rancherClient *RancherClient) *LoadBalancerServiceClient {
+	return &LoadBalancerServiceClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LoadBalancerServiceClient) Create(container *LoadBalancerService) (*LoadBalancerService, error) {
+	resp := &LoadBalancerService{}
+	err := c.rancherClient.doCreate(LOAD_BALANCER_SERVICE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) Update(existing *LoadBalancerService, updates interface{}) (*LoadBalancerService, error) {
+	resp := &LoadBalancerService{}
+	err := c.rancherClient.doUpdate(LOAD_BALANCER_SERVICE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) List(opts *ListOpts) (*LoadBalancerServiceCollection, error) {
+	resp := &LoadBalancerServiceCollection{}
+	err := c.rancherClient.doList(LOAD_BALANCER_SERVICE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LoadBalancerServiceCollection) Next() (*LoadBalancerServiceCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LoadBalancerServiceCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LoadBalancerServiceClient) ById(id string) (*LoadBalancerService, error) {
+	resp := &LoadBalancerService{}
+	err := c.rancherClient.doById(LOAD_BALANCER_SERVICE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) Delete(container *LoadBalancerService) error {
+	return c.rancherClient.doResourceDelete(LOAD_BALANCER_SERVICE_TYPE, &container.Resource)
+}
+
+func (c *LoadBalancerServiceClient) ActionActivate(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionAddservicelink(resource *LoadBalancerService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "addservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionCancelupgrade(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionContinueupgrade(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "continueupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionCreate(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionDeactivate(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionFinishupgrade(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionRemove(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionRemoveservicelink(resource *LoadBalancerService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "removeservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionRestart(resource *LoadBalancerService, input *ServiceRestart) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionRollback(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionSetservicelinks(resource *LoadBalancerService, input *SetServiceLinksInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "setservicelinks", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionUpdate(resource *LoadBalancerService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *LoadBalancerServiceClient) ActionUpgrade(resource *LoadBalancerService, input *ServiceUpgrade) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(LOAD_BALANCER_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_local_auth_config.go

@@ -0,0 +1,87 @@
+package client
+
+const (
+	LOCAL_AUTH_CONFIG_TYPE = "localAuthConfig"
+)
+
+type LocalAuthConfig struct {
+	Resource
+
+	AccessMode string `json:"accessMode,omitempty" yaml:"access_mode,omitempty"`
+
+	Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Password string `json:"password,omitempty" yaml:"password,omitempty"`
+
+	Username string `json:"username,omitempty" yaml:"username,omitempty"`
+}
+
+type LocalAuthConfigCollection struct {
+	Collection
+	Data   []LocalAuthConfig `json:"data,omitempty"`
+	client *LocalAuthConfigClient
+}
+
+type LocalAuthConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type LocalAuthConfigOperations interface {
+	List(opts *ListOpts) (*LocalAuthConfigCollection, error)
+	Create(opts *LocalAuthConfig) (*LocalAuthConfig, error)
+	Update(existing *LocalAuthConfig, updates interface{}) (*LocalAuthConfig, error)
+	ById(id string) (*LocalAuthConfig, error)
+	Delete(container *LocalAuthConfig) error
+}
+
+func newLocalAuthConfigClient(rancherClient *RancherClient) *LocalAuthConfigClient {
+	return &LocalAuthConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LocalAuthConfigClient) Create(container *LocalAuthConfig) (*LocalAuthConfig, error) {
+	resp := &LocalAuthConfig{}
+	err := c.rancherClient.doCreate(LOCAL_AUTH_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LocalAuthConfigClient) Update(existing *LocalAuthConfig, updates interface{}) (*LocalAuthConfig, error) {
+	resp := &LocalAuthConfig{}
+	err := c.rancherClient.doUpdate(LOCAL_AUTH_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LocalAuthConfigClient) List(opts *ListOpts) (*LocalAuthConfigCollection, error) {
+	resp := &LocalAuthConfigCollection{}
+	err := c.rancherClient.doList(LOCAL_AUTH_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LocalAuthConfigCollection) Next() (*LocalAuthConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LocalAuthConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LocalAuthConfigClient) ById(id string) (*LocalAuthConfig, error) {
+	resp := &LocalAuthConfig{}
+	err := c.rancherClient.doById(LOCAL_AUTH_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LocalAuthConfigClient) Delete(container *LocalAuthConfig) error {
+	return c.rancherClient.doResourceDelete(LOCAL_AUTH_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_log_config.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	LOG_CONFIG_TYPE = "logConfig"
+)
+
+type LogConfig struct {
+	Resource
+
+	Config map[string]interface{} `json:"config,omitempty" yaml:"config,omitempty"`
+
+	Driver string `json:"driver,omitempty" yaml:"driver,omitempty"`
+}
+
+type LogConfigCollection struct {
+	Collection
+	Data   []LogConfig `json:"data,omitempty"`
+	client *LogConfigClient
+}
+
+type LogConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type LogConfigOperations interface {
+	List(opts *ListOpts) (*LogConfigCollection, error)
+	Create(opts *LogConfig) (*LogConfig, error)
+	Update(existing *LogConfig, updates interface{}) (*LogConfig, error)
+	ById(id string) (*LogConfig, error)
+	Delete(container *LogConfig) error
+}
+
+func newLogConfigClient(rancherClient *RancherClient) *LogConfigClient {
+	return &LogConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *LogConfigClient) Create(container *LogConfig) (*LogConfig, error) {
+	resp := &LogConfig{}
+	err := c.rancherClient.doCreate(LOG_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *LogConfigClient) Update(existing *LogConfig, updates interface{}) (*LogConfig, error) {
+	resp := &LogConfig{}
+	err := c.rancherClient.doUpdate(LOG_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *LogConfigClient) List(opts *ListOpts) (*LogConfigCollection, error) {
+	resp := &LogConfigCollection{}
+	err := c.rancherClient.doList(LOG_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *LogConfigCollection) Next() (*LogConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &LogConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *LogConfigClient) ById(id string) (*LogConfig, error) {
+	resp := &LogConfig{}
+	err := c.rancherClient.doById(LOG_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *LogConfigClient) Delete(container *LogConfig) error {
+	return c.rancherClient.doResourceDelete(LOG_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_machine.go

@@ -0,0 +1,194 @@
+package client
+
+const (
+	MACHINE_TYPE = "machine"
+)
+
+type Machine struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Amazonec2Config *Amazonec2Config `json:"amazonec2Config,omitempty" yaml:"amazonec2config,omitempty"`
+
+	AuthCertificateAuthority string `json:"authCertificateAuthority,omitempty" yaml:"auth_certificate_authority,omitempty"`
+
+	AuthKey string `json:"authKey,omitempty" yaml:"auth_key,omitempty"`
+
+	AzureConfig *AzureConfig `json:"azureConfig,omitempty" yaml:"azure_config,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	DigitaloceanConfig *DigitaloceanConfig `json:"digitaloceanConfig,omitempty" yaml:"digitalocean_config,omitempty"`
+
+	DockerVersion string `json:"dockerVersion,omitempty" yaml:"docker_version,omitempty"`
+
+	Driver string `json:"driver,omitempty" yaml:"driver,omitempty"`
+
+	EngineEnv map[string]interface{} `json:"engineEnv,omitempty" yaml:"engine_env,omitempty"`
+
+	EngineInsecureRegistry []string `json:"engineInsecureRegistry,omitempty" yaml:"engine_insecure_registry,omitempty"`
+
+	EngineInstallUrl string `json:"engineInstallUrl,omitempty" yaml:"engine_install_url,omitempty"`
+
+	EngineLabel map[string]interface{} `json:"engineLabel,omitempty" yaml:"engine_label,omitempty"`
+
+	EngineOpt map[string]interface{} `json:"engineOpt,omitempty" yaml:"engine_opt,omitempty"`
+
+	EngineRegistryMirror []string `json:"engineRegistryMirror,omitempty" yaml:"engine_registry_mirror,omitempty"`
+
+	EngineStorageDriver string `json:"engineStorageDriver,omitempty" yaml:"engine_storage_driver,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	HostTemplateId string `json:"hostTemplateId,omitempty" yaml:"host_template_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Labels map[string]interface{} `json:"labels,omitempty" yaml:"labels,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PacketConfig *PacketConfig `json:"packetConfig,omitempty" yaml:"packet_config,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type MachineCollection struct {
+	Collection
+	Data   []Machine `json:"data,omitempty"`
+	client *MachineClient
+}
+
+type MachineClient struct {
+	rancherClient *RancherClient
+}
+
+type MachineOperations interface {
+	List(opts *ListOpts) (*MachineCollection, error)
+	Create(opts *Machine) (*Machine, error)
+	Update(existing *Machine, updates interface{}) (*Machine, error)
+	ById(id string) (*Machine, error)
+	Delete(container *Machine) error
+
+	ActionBootstrap(*Machine) (*PhysicalHost, error)
+
+	ActionCreate(*Machine) (*PhysicalHost, error)
+
+	ActionError(*Machine) (*PhysicalHost, error)
+
+	ActionRemove(*Machine) (*PhysicalHost, error)
+
+	ActionUpdate(*Machine) (*PhysicalHost, error)
+}
+
+func newMachineClient(rancherClient *RancherClient) *MachineClient {
+	return &MachineClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *MachineClient) Create(container *Machine) (*Machine, error) {
+	resp := &Machine{}
+	err := c.rancherClient.doCreate(MACHINE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *MachineClient) Update(existing *Machine, updates interface{}) (*Machine, error) {
+	resp := &Machine{}
+	err := c.rancherClient.doUpdate(MACHINE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *MachineClient) List(opts *ListOpts) (*MachineCollection, error) {
+	resp := &MachineCollection{}
+	err := c.rancherClient.doList(MACHINE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *MachineCollection) Next() (*MachineCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &MachineCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *MachineClient) ById(id string) (*Machine, error) {
+	resp := &Machine{}
+	err := c.rancherClient.doById(MACHINE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *MachineClient) Delete(container *Machine) error {
+	return c.rancherClient.doResourceDelete(MACHINE_TYPE, &container.Resource)
+}
+
+func (c *MachineClient) ActionBootstrap(resource *Machine) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(MACHINE_TYPE, "bootstrap", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineClient) ActionCreate(resource *Machine) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(MACHINE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineClient) ActionError(resource *Machine) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(MACHINE_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineClient) ActionRemove(resource *Machine) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(MACHINE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineClient) ActionUpdate(resource *Machine) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(MACHINE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_machine_driver.go

@@ -0,0 +1,192 @@
+package client
+
+const (
+	MACHINE_DRIVER_TYPE = "machineDriver"
+)
+
+type MachineDriver struct {
+	Resource
+
+	ActivateOnCreate bool `json:"activateOnCreate,omitempty" yaml:"activate_on_create,omitempty"`
+
+	Builtin bool `json:"builtin,omitempty" yaml:"builtin,omitempty"`
+
+	Checksum string `json:"checksum,omitempty" yaml:"checksum,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DefaultActive bool `json:"defaultActive,omitempty" yaml:"default_active,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	UiUrl string `json:"uiUrl,omitempty" yaml:"ui_url,omitempty"`
+
+	Url string `json:"url,omitempty" yaml:"url,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type MachineDriverCollection struct {
+	Collection
+	Data   []MachineDriver `json:"data,omitempty"`
+	client *MachineDriverClient
+}
+
+type MachineDriverClient struct {
+	rancherClient *RancherClient
+}
+
+type MachineDriverOperations interface {
+	List(opts *ListOpts) (*MachineDriverCollection, error)
+	Create(opts *MachineDriver) (*MachineDriver, error)
+	Update(existing *MachineDriver, updates interface{}) (*MachineDriver, error)
+	ById(id string) (*MachineDriver, error)
+	Delete(container *MachineDriver) error
+
+	ActionActivate(*MachineDriver) (*MachineDriver, error)
+
+	ActionCreate(*MachineDriver) (*MachineDriver, error)
+
+	ActionDeactivate(*MachineDriver) (*MachineDriver, error)
+
+	ActionError(*MachineDriver) (*MachineDriver, error)
+
+	ActionReactivate(*MachineDriver) (*MachineDriver, error)
+
+	ActionRemove(*MachineDriver) (*MachineDriver, error)
+
+	ActionUpdate(*MachineDriver) (*MachineDriver, error)
+}
+
+func newMachineDriverClient(rancherClient *RancherClient) *MachineDriverClient {
+	return &MachineDriverClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *MachineDriverClient) Create(container *MachineDriver) (*MachineDriver, error) {
+	resp := &MachineDriver{}
+	err := c.rancherClient.doCreate(MACHINE_DRIVER_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *MachineDriverClient) Update(existing *MachineDriver, updates interface{}) (*MachineDriver, error) {
+	resp := &MachineDriver{}
+	err := c.rancherClient.doUpdate(MACHINE_DRIVER_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *MachineDriverClient) List(opts *ListOpts) (*MachineDriverCollection, error) {
+	resp := &MachineDriverCollection{}
+	err := c.rancherClient.doList(MACHINE_DRIVER_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *MachineDriverCollection) Next() (*MachineDriverCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &MachineDriverCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *MachineDriverClient) ById(id string) (*MachineDriver, error) {
+	resp := &MachineDriver{}
+	err := c.rancherClient.doById(MACHINE_DRIVER_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *MachineDriverClient) Delete(container *MachineDriver) error {
+	return c.rancherClient.doResourceDelete(MACHINE_DRIVER_TYPE, &container.Resource)
+}
+
+func (c *MachineDriverClient) ActionActivate(resource *MachineDriver) (*MachineDriver, error) {
+
+	resp := &MachineDriver{}
+
+	err := c.rancherClient.doAction(MACHINE_DRIVER_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineDriverClient) ActionCreate(resource *MachineDriver) (*MachineDriver, error) {
+
+	resp := &MachineDriver{}
+
+	err := c.rancherClient.doAction(MACHINE_DRIVER_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineDriverClient) ActionDeactivate(resource *MachineDriver) (*MachineDriver, error) {
+
+	resp := &MachineDriver{}
+
+	err := c.rancherClient.doAction(MACHINE_DRIVER_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineDriverClient) ActionError(resource *MachineDriver) (*MachineDriver, error) {
+
+	resp := &MachineDriver{}
+
+	err := c.rancherClient.doAction(MACHINE_DRIVER_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineDriverClient) ActionReactivate(resource *MachineDriver) (*MachineDriver, error) {
+
+	resp := &MachineDriver{}
+
+	err := c.rancherClient.doAction(MACHINE_DRIVER_TYPE, "reactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineDriverClient) ActionRemove(resource *MachineDriver) (*MachineDriver, error) {
+
+	resp := &MachineDriver{}
+
+	err := c.rancherClient.doAction(MACHINE_DRIVER_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MachineDriverClient) ActionUpdate(resource *MachineDriver) (*MachineDriver, error) {
+
+	resp := &MachineDriver{}
+
+	err := c.rancherClient.doAction(MACHINE_DRIVER_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_mount.go

@@ -0,0 +1,144 @@
+package client
+
+const (
+	MOUNT_TYPE = "mount"
+)
+
+type Mount struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	InstanceId string `json:"instanceId,omitempty" yaml:"instance_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Path string `json:"path,omitempty" yaml:"path,omitempty"`
+
+	Permissions string `json:"permissions,omitempty" yaml:"permissions,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	VolumeId string `json:"volumeId,omitempty" yaml:"volume_id,omitempty"`
+}
+
+type MountCollection struct {
+	Collection
+	Data   []Mount `json:"data,omitempty"`
+	client *MountClient
+}
+
+type MountClient struct {
+	rancherClient *RancherClient
+}
+
+type MountOperations interface {
+	List(opts *ListOpts) (*MountCollection, error)
+	Create(opts *Mount) (*Mount, error)
+	Update(existing *Mount, updates interface{}) (*Mount, error)
+	ById(id string) (*Mount, error)
+	Delete(container *Mount) error
+
+	ActionCreate(*Mount) (*Mount, error)
+
+	ActionDeactivate(*Mount) (*Mount, error)
+
+	ActionRemove(*Mount) (*Mount, error)
+}
+
+func newMountClient(rancherClient *RancherClient) *MountClient {
+	return &MountClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *MountClient) Create(container *Mount) (*Mount, error) {
+	resp := &Mount{}
+	err := c.rancherClient.doCreate(MOUNT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *MountClient) Update(existing *Mount, updates interface{}) (*Mount, error) {
+	resp := &Mount{}
+	err := c.rancherClient.doUpdate(MOUNT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *MountClient) List(opts *ListOpts) (*MountCollection, error) {
+	resp := &MountCollection{}
+	err := c.rancherClient.doList(MOUNT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *MountCollection) Next() (*MountCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &MountCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *MountClient) ById(id string) (*Mount, error) {
+	resp := &Mount{}
+	err := c.rancherClient.doById(MOUNT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *MountClient) Delete(container *Mount) error {
+	return c.rancherClient.doResourceDelete(MOUNT_TYPE, &container.Resource)
+}
+
+func (c *MountClient) ActionCreate(resource *Mount) (*Mount, error) {
+
+	resp := &Mount{}
+
+	err := c.rancherClient.doAction(MOUNT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MountClient) ActionDeactivate(resource *Mount) (*Mount, error) {
+
+	resp := &Mount{}
+
+	err := c.rancherClient.doAction(MOUNT_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *MountClient) ActionRemove(resource *Mount) (*Mount, error) {
+
+	resp := &Mount{}
+
+	err := c.rancherClient.doAction(MOUNT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_mount_entry.go

@@ -0,0 +1,87 @@
+package client
+
+const (
+	MOUNT_ENTRY_TYPE = "mountEntry"
+)
+
+type MountEntry struct {
+	Resource
+
+	InstanceId string `json:"instanceId,omitempty" yaml:"instance_id,omitempty"`
+
+	InstanceName string `json:"instanceName,omitempty" yaml:"instance_name,omitempty"`
+
+	Path string `json:"path,omitempty" yaml:"path,omitempty"`
+
+	VolumeId string `json:"volumeId,omitempty" yaml:"volume_id,omitempty"`
+
+	VolumeName string `json:"volumeName,omitempty" yaml:"volume_name,omitempty"`
+}
+
+type MountEntryCollection struct {
+	Collection
+	Data   []MountEntry `json:"data,omitempty"`
+	client *MountEntryClient
+}
+
+type MountEntryClient struct {
+	rancherClient *RancherClient
+}
+
+type MountEntryOperations interface {
+	List(opts *ListOpts) (*MountEntryCollection, error)
+	Create(opts *MountEntry) (*MountEntry, error)
+	Update(existing *MountEntry, updates interface{}) (*MountEntry, error)
+	ById(id string) (*MountEntry, error)
+	Delete(container *MountEntry) error
+}
+
+func newMountEntryClient(rancherClient *RancherClient) *MountEntryClient {
+	return &MountEntryClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *MountEntryClient) Create(container *MountEntry) (*MountEntry, error) {
+	resp := &MountEntry{}
+	err := c.rancherClient.doCreate(MOUNT_ENTRY_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *MountEntryClient) Update(existing *MountEntry, updates interface{}) (*MountEntry, error) {
+	resp := &MountEntry{}
+	err := c.rancherClient.doUpdate(MOUNT_ENTRY_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *MountEntryClient) List(opts *ListOpts) (*MountEntryCollection, error) {
+	resp := &MountEntryCollection{}
+	err := c.rancherClient.doList(MOUNT_ENTRY_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *MountEntryCollection) Next() (*MountEntryCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &MountEntryCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *MountEntryClient) ById(id string) (*MountEntry, error) {
+	resp := &MountEntry{}
+	err := c.rancherClient.doById(MOUNT_ENTRY_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *MountEntryClient) Delete(container *MountEntry) error {
+	return c.rancherClient.doResourceDelete(MOUNT_ENTRY_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_network.go

@@ -0,0 +1,185 @@
+package client
+
+const (
+	NETWORK_TYPE = "network"
+)
+
+type Network struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DefaultPolicyAction string `json:"defaultPolicyAction,omitempty" yaml:"default_policy_action,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Dns []string `json:"dns,omitempty" yaml:"dns,omitempty"`
+
+	DnsSearch []string `json:"dnsSearch,omitempty" yaml:"dns_search,omitempty"`
+
+	HostPorts bool `json:"hostPorts,omitempty" yaml:"host_ports,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	NetworkDriverId string `json:"networkDriverId,omitempty" yaml:"network_driver_id,omitempty"`
+
+	Policy []NetworkPolicyRule `json:"policy,omitempty" yaml:"policy,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Subnets []Subnet `json:"subnets,omitempty" yaml:"subnets,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type NetworkCollection struct {
+	Collection
+	Data   []Network `json:"data,omitempty"`
+	client *NetworkClient
+}
+
+type NetworkClient struct {
+	rancherClient *RancherClient
+}
+
+type NetworkOperations interface {
+	List(opts *ListOpts) (*NetworkCollection, error)
+	Create(opts *Network) (*Network, error)
+	Update(existing *Network, updates interface{}) (*Network, error)
+	ById(id string) (*Network, error)
+	Delete(container *Network) error
+
+	ActionActivate(*Network) (*Network, error)
+
+	ActionCreate(*Network) (*Network, error)
+
+	ActionDeactivate(*Network) (*Network, error)
+
+	ActionPurge(*Network) (*Network, error)
+
+	ActionRemove(*Network) (*Network, error)
+
+	ActionUpdate(*Network) (*Network, error)
+}
+
+func newNetworkClient(rancherClient *RancherClient) *NetworkClient {
+	return &NetworkClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NetworkClient) Create(container *Network) (*Network, error) {
+	resp := &Network{}
+	err := c.rancherClient.doCreate(NETWORK_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NetworkClient) Update(existing *Network, updates interface{}) (*Network, error) {
+	resp := &Network{}
+	err := c.rancherClient.doUpdate(NETWORK_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NetworkClient) List(opts *ListOpts) (*NetworkCollection, error) {
+	resp := &NetworkCollection{}
+	err := c.rancherClient.doList(NETWORK_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NetworkCollection) Next() (*NetworkCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NetworkCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NetworkClient) ById(id string) (*Network, error) {
+	resp := &Network{}
+	err := c.rancherClient.doById(NETWORK_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NetworkClient) Delete(container *Network) error {
+	return c.rancherClient.doResourceDelete(NETWORK_TYPE, &container.Resource)
+}
+
+func (c *NetworkClient) ActionActivate(resource *Network) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(NETWORK_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkClient) ActionCreate(resource *Network) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(NETWORK_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkClient) ActionDeactivate(resource *Network) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(NETWORK_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkClient) ActionPurge(resource *Network) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(NETWORK_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkClient) ActionRemove(resource *Network) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(NETWORK_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkClient) ActionUpdate(resource *Network) (*Network, error) {
+
+	resp := &Network{}
+
+	err := c.rancherClient.doAction(NETWORK_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_network_driver.go

@@ -0,0 +1,166 @@
+package client
+
+const (
+	NETWORK_DRIVER_TYPE = "networkDriver"
+)
+
+type NetworkDriver struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	CniConfig map[string]interface{} `json:"cniConfig,omitempty" yaml:"cni_config,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	DefaultNetwork DefaultNetwork `json:"defaultNetwork,omitempty" yaml:"default_network,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	NetworkMetadata map[string]interface{} `json:"networkMetadata,omitempty" yaml:"network_metadata,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	ServiceId string `json:"serviceId,omitempty" yaml:"service_id,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type NetworkDriverCollection struct {
+	Collection
+	Data   []NetworkDriver `json:"data,omitempty"`
+	client *NetworkDriverClient
+}
+
+type NetworkDriverClient struct {
+	rancherClient *RancherClient
+}
+
+type NetworkDriverOperations interface {
+	List(opts *ListOpts) (*NetworkDriverCollection, error)
+	Create(opts *NetworkDriver) (*NetworkDriver, error)
+	Update(existing *NetworkDriver, updates interface{}) (*NetworkDriver, error)
+	ById(id string) (*NetworkDriver, error)
+	Delete(container *NetworkDriver) error
+
+	ActionActivate(*NetworkDriver) (*NetworkDriver, error)
+
+	ActionCreate(*NetworkDriver) (*NetworkDriver, error)
+
+	ActionDeactivate(*NetworkDriver) (*NetworkDriver, error)
+
+	ActionRemove(*NetworkDriver) (*NetworkDriver, error)
+
+	ActionUpdate(*NetworkDriver) (*NetworkDriver, error)
+}
+
+func newNetworkDriverClient(rancherClient *RancherClient) *NetworkDriverClient {
+	return &NetworkDriverClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NetworkDriverClient) Create(container *NetworkDriver) (*NetworkDriver, error) {
+	resp := &NetworkDriver{}
+	err := c.rancherClient.doCreate(NETWORK_DRIVER_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NetworkDriverClient) Update(existing *NetworkDriver, updates interface{}) (*NetworkDriver, error) {
+	resp := &NetworkDriver{}
+	err := c.rancherClient.doUpdate(NETWORK_DRIVER_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NetworkDriverClient) List(opts *ListOpts) (*NetworkDriverCollection, error) {
+	resp := &NetworkDriverCollection{}
+	err := c.rancherClient.doList(NETWORK_DRIVER_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NetworkDriverCollection) Next() (*NetworkDriverCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NetworkDriverCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NetworkDriverClient) ById(id string) (*NetworkDriver, error) {
+	resp := &NetworkDriver{}
+	err := c.rancherClient.doById(NETWORK_DRIVER_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NetworkDriverClient) Delete(container *NetworkDriver) error {
+	return c.rancherClient.doResourceDelete(NETWORK_DRIVER_TYPE, &container.Resource)
+}
+
+func (c *NetworkDriverClient) ActionActivate(resource *NetworkDriver) (*NetworkDriver, error) {
+
+	resp := &NetworkDriver{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverClient) ActionCreate(resource *NetworkDriver) (*NetworkDriver, error) {
+
+	resp := &NetworkDriver{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverClient) ActionDeactivate(resource *NetworkDriver) (*NetworkDriver, error) {
+
+	resp := &NetworkDriver{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverClient) ActionRemove(resource *NetworkDriver) (*NetworkDriver, error) {
+
+	resp := &NetworkDriver{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverClient) ActionUpdate(resource *NetworkDriver) (*NetworkDriver, error) {
+
+	resp := &NetworkDriver{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_network_driver_service.go

@@ -0,0 +1,305 @@
+package client
+
+const (
+	NETWORK_DRIVER_SERVICE_TYPE = "networkDriverService"
+)
+
+type NetworkDriverService struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	AssignServiceIpAddress bool `json:"assignServiceIpAddress,omitempty" yaml:"assign_service_ip_address,omitempty"`
+
+	CreateIndex int64 `json:"createIndex,omitempty" yaml:"create_index,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	CurrentScale int64 `json:"currentScale,omitempty" yaml:"current_scale,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
+
+	HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
+
+	InstanceIds []string `json:"instanceIds,omitempty" yaml:"instance_ids,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
+
+	LbConfig *LbTargetConfig `json:"lbConfig,omitempty" yaml:"lb_config,omitempty"`
+
+	LinkedServices map[string]interface{} `json:"linkedServices,omitempty" yaml:"linked_services,omitempty"`
+
+	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	NetworkDriver NetworkDriver `json:"networkDriver,omitempty" yaml:"network_driver,omitempty"`
+
+	PublicEndpoints []PublicEndpoint `json:"publicEndpoints,omitempty" yaml:"public_endpoints,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	RetainIp bool `json:"retainIp,omitempty" yaml:"retain_ip,omitempty"`
+
+	Scale int64 `json:"scale,omitempty" yaml:"scale,omitempty"`
+
+	ScalePolicy *ScalePolicy `json:"scalePolicy,omitempty" yaml:"scale_policy,omitempty"`
+
+	SecondaryLaunchConfigs []SecondaryLaunchConfig `json:"secondaryLaunchConfigs,omitempty" yaml:"secondary_launch_configs,omitempty"`
+
+	SelectorContainer string `json:"selectorContainer,omitempty" yaml:"selector_container,omitempty"`
+
+	SelectorLink string `json:"selectorLink,omitempty" yaml:"selector_link,omitempty"`
+
+	StackId string `json:"stackId,omitempty" yaml:"stack_id,omitempty"`
+
+	StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	System bool `json:"system,omitempty" yaml:"system,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Upgrade *ServiceUpgrade `json:"upgrade,omitempty" yaml:"upgrade,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+
+	Vip string `json:"vip,omitempty" yaml:"vip,omitempty"`
+}
+
+type NetworkDriverServiceCollection struct {
+	Collection
+	Data   []NetworkDriverService `json:"data,omitempty"`
+	client *NetworkDriverServiceClient
+}
+
+type NetworkDriverServiceClient struct {
+	rancherClient *RancherClient
+}
+
+type NetworkDriverServiceOperations interface {
+	List(opts *ListOpts) (*NetworkDriverServiceCollection, error)
+	Create(opts *NetworkDriverService) (*NetworkDriverService, error)
+	Update(existing *NetworkDriverService, updates interface{}) (*NetworkDriverService, error)
+	ById(id string) (*NetworkDriverService, error)
+	Delete(container *NetworkDriverService) error
+
+	ActionActivate(*NetworkDriverService) (*Service, error)
+
+	ActionAddservicelink(*NetworkDriverService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionCancelupgrade(*NetworkDriverService) (*Service, error)
+
+	ActionContinueupgrade(*NetworkDriverService) (*Service, error)
+
+	ActionCreate(*NetworkDriverService) (*Service, error)
+
+	ActionDeactivate(*NetworkDriverService) (*Service, error)
+
+	ActionFinishupgrade(*NetworkDriverService) (*Service, error)
+
+	ActionRemove(*NetworkDriverService) (*Service, error)
+
+	ActionRemoveservicelink(*NetworkDriverService, *AddRemoveServiceLinkInput) (*Service, error)
+
+	ActionRestart(*NetworkDriverService, *ServiceRestart) (*Service, error)
+
+	ActionRollback(*NetworkDriverService) (*Service, error)
+
+	ActionSetservicelinks(*NetworkDriverService, *SetServiceLinksInput) (*Service, error)
+
+	ActionUpdate(*NetworkDriverService) (*Service, error)
+
+	ActionUpgrade(*NetworkDriverService, *ServiceUpgrade) (*Service, error)
+}
+
+func newNetworkDriverServiceClient(rancherClient *RancherClient) *NetworkDriverServiceClient {
+	return &NetworkDriverServiceClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NetworkDriverServiceClient) Create(container *NetworkDriverService) (*NetworkDriverService, error) {
+	resp := &NetworkDriverService{}
+	err := c.rancherClient.doCreate(NETWORK_DRIVER_SERVICE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) Update(existing *NetworkDriverService, updates interface{}) (*NetworkDriverService, error) {
+	resp := &NetworkDriverService{}
+	err := c.rancherClient.doUpdate(NETWORK_DRIVER_SERVICE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) List(opts *ListOpts) (*NetworkDriverServiceCollection, error) {
+	resp := &NetworkDriverServiceCollection{}
+	err := c.rancherClient.doList(NETWORK_DRIVER_SERVICE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NetworkDriverServiceCollection) Next() (*NetworkDriverServiceCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NetworkDriverServiceCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NetworkDriverServiceClient) ById(id string) (*NetworkDriverService, error) {
+	resp := &NetworkDriverService{}
+	err := c.rancherClient.doById(NETWORK_DRIVER_SERVICE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) Delete(container *NetworkDriverService) error {
+	return c.rancherClient.doResourceDelete(NETWORK_DRIVER_SERVICE_TYPE, &container.Resource)
+}
+
+func (c *NetworkDriverServiceClient) ActionActivate(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionAddservicelink(resource *NetworkDriverService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "addservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionCancelupgrade(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionContinueupgrade(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "continueupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionCreate(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionDeactivate(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionFinishupgrade(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionRemove(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionRemoveservicelink(resource *NetworkDriverService, input *AddRemoveServiceLinkInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "removeservicelink", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionRestart(resource *NetworkDriverService, input *ServiceRestart) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionRollback(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionSetservicelinks(resource *NetworkDriverService, input *SetServiceLinksInput) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "setservicelinks", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionUpdate(resource *NetworkDriverService) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *NetworkDriverServiceClient) ActionUpgrade(resource *NetworkDriverService, input *ServiceUpgrade) (*Service, error) {
+
+	resp := &Service{}
+
+	err := c.rancherClient.doAction(NETWORK_DRIVER_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_network_policy_rule.go

@@ -0,0 +1,89 @@
+package client
+
+const (
+	NETWORK_POLICY_RULE_TYPE = "networkPolicyRule"
+)
+
+type NetworkPolicyRule struct {
+	Resource
+
+	Action string `json:"action,omitempty" yaml:"action,omitempty"`
+
+	Between NetworkPolicyRuleBetween `json:"between,omitempty" yaml:"between,omitempty"`
+
+	From NetworkPolicyRuleMember `json:"from,omitempty" yaml:"from,omitempty"`
+
+	Ports []string `json:"ports,omitempty" yaml:"ports,omitempty"`
+
+	To NetworkPolicyRuleMember `json:"to,omitempty" yaml:"to,omitempty"`
+
+	Within string `json:"within,omitempty" yaml:"within,omitempty"`
+}
+
+type NetworkPolicyRuleCollection struct {
+	Collection
+	Data   []NetworkPolicyRule `json:"data,omitempty"`
+	client *NetworkPolicyRuleClient
+}
+
+type NetworkPolicyRuleClient struct {
+	rancherClient *RancherClient
+}
+
+type NetworkPolicyRuleOperations interface {
+	List(opts *ListOpts) (*NetworkPolicyRuleCollection, error)
+	Create(opts *NetworkPolicyRule) (*NetworkPolicyRule, error)
+	Update(existing *NetworkPolicyRule, updates interface{}) (*NetworkPolicyRule, error)
+	ById(id string) (*NetworkPolicyRule, error)
+	Delete(container *NetworkPolicyRule) error
+}
+
+func newNetworkPolicyRuleClient(rancherClient *RancherClient) *NetworkPolicyRuleClient {
+	return &NetworkPolicyRuleClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NetworkPolicyRuleClient) Create(container *NetworkPolicyRule) (*NetworkPolicyRule, error) {
+	resp := &NetworkPolicyRule{}
+	err := c.rancherClient.doCreate(NETWORK_POLICY_RULE_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleClient) Update(existing *NetworkPolicyRule, updates interface{}) (*NetworkPolicyRule, error) {
+	resp := &NetworkPolicyRule{}
+	err := c.rancherClient.doUpdate(NETWORK_POLICY_RULE_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleClient) List(opts *ListOpts) (*NetworkPolicyRuleCollection, error) {
+	resp := &NetworkPolicyRuleCollection{}
+	err := c.rancherClient.doList(NETWORK_POLICY_RULE_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NetworkPolicyRuleCollection) Next() (*NetworkPolicyRuleCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NetworkPolicyRuleCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NetworkPolicyRuleClient) ById(id string) (*NetworkPolicyRule, error) {
+	resp := &NetworkPolicyRule{}
+	err := c.rancherClient.doById(NETWORK_POLICY_RULE_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleClient) Delete(container *NetworkPolicyRule) error {
+	return c.rancherClient.doResourceDelete(NETWORK_POLICY_RULE_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_network_policy_rule_between.go

@@ -0,0 +1,81 @@
+package client
+
+const (
+	NETWORK_POLICY_RULE_BETWEEN_TYPE = "networkPolicyRuleBetween"
+)
+
+type NetworkPolicyRuleBetween struct {
+	Resource
+
+	GroupBy string `json:"groupBy,omitempty" yaml:"group_by,omitempty"`
+
+	Selector string `json:"selector,omitempty" yaml:"selector,omitempty"`
+}
+
+type NetworkPolicyRuleBetweenCollection struct {
+	Collection
+	Data   []NetworkPolicyRuleBetween `json:"data,omitempty"`
+	client *NetworkPolicyRuleBetweenClient
+}
+
+type NetworkPolicyRuleBetweenClient struct {
+	rancherClient *RancherClient
+}
+
+type NetworkPolicyRuleBetweenOperations interface {
+	List(opts *ListOpts) (*NetworkPolicyRuleBetweenCollection, error)
+	Create(opts *NetworkPolicyRuleBetween) (*NetworkPolicyRuleBetween, error)
+	Update(existing *NetworkPolicyRuleBetween, updates interface{}) (*NetworkPolicyRuleBetween, error)
+	ById(id string) (*NetworkPolicyRuleBetween, error)
+	Delete(container *NetworkPolicyRuleBetween) error
+}
+
+func newNetworkPolicyRuleBetweenClient(rancherClient *RancherClient) *NetworkPolicyRuleBetweenClient {
+	return &NetworkPolicyRuleBetweenClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NetworkPolicyRuleBetweenClient) Create(container *NetworkPolicyRuleBetween) (*NetworkPolicyRuleBetween, error) {
+	resp := &NetworkPolicyRuleBetween{}
+	err := c.rancherClient.doCreate(NETWORK_POLICY_RULE_BETWEEN_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleBetweenClient) Update(existing *NetworkPolicyRuleBetween, updates interface{}) (*NetworkPolicyRuleBetween, error) {
+	resp := &NetworkPolicyRuleBetween{}
+	err := c.rancherClient.doUpdate(NETWORK_POLICY_RULE_BETWEEN_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleBetweenClient) List(opts *ListOpts) (*NetworkPolicyRuleBetweenCollection, error) {
+	resp := &NetworkPolicyRuleBetweenCollection{}
+	err := c.rancherClient.doList(NETWORK_POLICY_RULE_BETWEEN_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NetworkPolicyRuleBetweenCollection) Next() (*NetworkPolicyRuleBetweenCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NetworkPolicyRuleBetweenCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NetworkPolicyRuleBetweenClient) ById(id string) (*NetworkPolicyRuleBetween, error) {
+	resp := &NetworkPolicyRuleBetween{}
+	err := c.rancherClient.doById(NETWORK_POLICY_RULE_BETWEEN_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleBetweenClient) Delete(container *NetworkPolicyRuleBetween) error {
+	return c.rancherClient.doResourceDelete(NETWORK_POLICY_RULE_BETWEEN_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_network_policy_rule_member.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	NETWORK_POLICY_RULE_MEMBER_TYPE = "networkPolicyRuleMember"
+)
+
+type NetworkPolicyRuleMember struct {
+	Resource
+
+	Selector string `json:"selector,omitempty" yaml:"selector,omitempty"`
+}
+
+type NetworkPolicyRuleMemberCollection struct {
+	Collection
+	Data   []NetworkPolicyRuleMember `json:"data,omitempty"`
+	client *NetworkPolicyRuleMemberClient
+}
+
+type NetworkPolicyRuleMemberClient struct {
+	rancherClient *RancherClient
+}
+
+type NetworkPolicyRuleMemberOperations interface {
+	List(opts *ListOpts) (*NetworkPolicyRuleMemberCollection, error)
+	Create(opts *NetworkPolicyRuleMember) (*NetworkPolicyRuleMember, error)
+	Update(existing *NetworkPolicyRuleMember, updates interface{}) (*NetworkPolicyRuleMember, error)
+	ById(id string) (*NetworkPolicyRuleMember, error)
+	Delete(container *NetworkPolicyRuleMember) error
+}
+
+func newNetworkPolicyRuleMemberClient(rancherClient *RancherClient) *NetworkPolicyRuleMemberClient {
+	return &NetworkPolicyRuleMemberClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NetworkPolicyRuleMemberClient) Create(container *NetworkPolicyRuleMember) (*NetworkPolicyRuleMember, error) {
+	resp := &NetworkPolicyRuleMember{}
+	err := c.rancherClient.doCreate(NETWORK_POLICY_RULE_MEMBER_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleMemberClient) Update(existing *NetworkPolicyRuleMember, updates interface{}) (*NetworkPolicyRuleMember, error) {
+	resp := &NetworkPolicyRuleMember{}
+	err := c.rancherClient.doUpdate(NETWORK_POLICY_RULE_MEMBER_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleMemberClient) List(opts *ListOpts) (*NetworkPolicyRuleMemberCollection, error) {
+	resp := &NetworkPolicyRuleMemberCollection{}
+	err := c.rancherClient.doList(NETWORK_POLICY_RULE_MEMBER_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NetworkPolicyRuleMemberCollection) Next() (*NetworkPolicyRuleMemberCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NetworkPolicyRuleMemberCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NetworkPolicyRuleMemberClient) ById(id string) (*NetworkPolicyRuleMember, error) {
+	resp := &NetworkPolicyRuleMember{}
+	err := c.rancherClient.doById(NETWORK_POLICY_RULE_MEMBER_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleMemberClient) Delete(container *NetworkPolicyRuleMember) error {
+	return c.rancherClient.doResourceDelete(NETWORK_POLICY_RULE_MEMBER_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_network_policy_rule_within.go

@@ -0,0 +1,77 @@
+package client
+
+const (
+	NETWORK_POLICY_RULE_WITHIN_TYPE = "networkPolicyRuleWithin"
+)
+
+type NetworkPolicyRuleWithin struct {
+	Resource
+}
+
+type NetworkPolicyRuleWithinCollection struct {
+	Collection
+	Data   []NetworkPolicyRuleWithin `json:"data,omitempty"`
+	client *NetworkPolicyRuleWithinClient
+}
+
+type NetworkPolicyRuleWithinClient struct {
+	rancherClient *RancherClient
+}
+
+type NetworkPolicyRuleWithinOperations interface {
+	List(opts *ListOpts) (*NetworkPolicyRuleWithinCollection, error)
+	Create(opts *NetworkPolicyRuleWithin) (*NetworkPolicyRuleWithin, error)
+	Update(existing *NetworkPolicyRuleWithin, updates interface{}) (*NetworkPolicyRuleWithin, error)
+	ById(id string) (*NetworkPolicyRuleWithin, error)
+	Delete(container *NetworkPolicyRuleWithin) error
+}
+
+func newNetworkPolicyRuleWithinClient(rancherClient *RancherClient) *NetworkPolicyRuleWithinClient {
+	return &NetworkPolicyRuleWithinClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NetworkPolicyRuleWithinClient) Create(container *NetworkPolicyRuleWithin) (*NetworkPolicyRuleWithin, error) {
+	resp := &NetworkPolicyRuleWithin{}
+	err := c.rancherClient.doCreate(NETWORK_POLICY_RULE_WITHIN_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleWithinClient) Update(existing *NetworkPolicyRuleWithin, updates interface{}) (*NetworkPolicyRuleWithin, error) {
+	resp := &NetworkPolicyRuleWithin{}
+	err := c.rancherClient.doUpdate(NETWORK_POLICY_RULE_WITHIN_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleWithinClient) List(opts *ListOpts) (*NetworkPolicyRuleWithinCollection, error) {
+	resp := &NetworkPolicyRuleWithinCollection{}
+	err := c.rancherClient.doList(NETWORK_POLICY_RULE_WITHIN_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NetworkPolicyRuleWithinCollection) Next() (*NetworkPolicyRuleWithinCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NetworkPolicyRuleWithinCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NetworkPolicyRuleWithinClient) ById(id string) (*NetworkPolicyRuleWithin, error) {
+	resp := &NetworkPolicyRuleWithin{}
+	err := c.rancherClient.doById(NETWORK_POLICY_RULE_WITHIN_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NetworkPolicyRuleWithinClient) Delete(container *NetworkPolicyRuleWithin) error {
+	return c.rancherClient.doResourceDelete(NETWORK_POLICY_RULE_WITHIN_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_nfs_config.go

@@ -0,0 +1,83 @@
+package client
+
+const (
+	NFS_CONFIG_TYPE = "nfsConfig"
+)
+
+type NfsConfig struct {
+	Resource
+
+	MountOptions string `json:"mountOptions,omitempty" yaml:"mount_options,omitempty"`
+
+	Server string `json:"server,omitempty" yaml:"server,omitempty"`
+
+	Share string `json:"share,omitempty" yaml:"share,omitempty"`
+}
+
+type NfsConfigCollection struct {
+	Collection
+	Data   []NfsConfig `json:"data,omitempty"`
+	client *NfsConfigClient
+}
+
+type NfsConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type NfsConfigOperations interface {
+	List(opts *ListOpts) (*NfsConfigCollection, error)
+	Create(opts *NfsConfig) (*NfsConfig, error)
+	Update(existing *NfsConfig, updates interface{}) (*NfsConfig, error)
+	ById(id string) (*NfsConfig, error)
+	Delete(container *NfsConfig) error
+}
+
+func newNfsConfigClient(rancherClient *RancherClient) *NfsConfigClient {
+	return &NfsConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *NfsConfigClient) Create(container *NfsConfig) (*NfsConfig, error) {
+	resp := &NfsConfig{}
+	err := c.rancherClient.doCreate(NFS_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *NfsConfigClient) Update(existing *NfsConfig, updates interface{}) (*NfsConfig, error) {
+	resp := &NfsConfig{}
+	err := c.rancherClient.doUpdate(NFS_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *NfsConfigClient) List(opts *ListOpts) (*NfsConfigCollection, error) {
+	resp := &NfsConfigCollection{}
+	err := c.rancherClient.doList(NFS_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *NfsConfigCollection) Next() (*NfsConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &NfsConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *NfsConfigClient) ById(id string) (*NfsConfig, error) {
+	resp := &NfsConfig{}
+	err := c.rancherClient.doById(NFS_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *NfsConfigClient) Delete(container *NfsConfig) error {
+	return c.rancherClient.doResourceDelete(NFS_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_openldapconfig.go

@@ -0,0 +1,129 @@
+package client
+
+const (
+	OPENLDAPCONFIG_TYPE = "openldapconfig"
+)
+
+type Openldapconfig struct {
+	Resource
+
+	AccessMode string `json:"accessMode,omitempty" yaml:"access_mode,omitempty"`
+
+	AllowedIdentities []Identity `json:"allowedIdentities,omitempty" yaml:"allowed_identities,omitempty"`
+
+	ConnectionTimeout int64 `json:"connectionTimeout,omitempty" yaml:"connection_timeout,omitempty"`
+
+	Domain string `json:"domain,omitempty" yaml:"domain,omitempty"`
+
+	Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
+
+	GroupDNField string `json:"groupDNField,omitempty" yaml:"group_dnfield,omitempty"`
+
+	GroupMemberMappingAttribute string `json:"groupMemberMappingAttribute,omitempty" yaml:"group_member_mapping_attribute,omitempty"`
+
+	GroupMemberUserAttribute string `json:"groupMemberUserAttribute,omitempty" yaml:"group_member_user_attribute,omitempty"`
+
+	GroupNameField string `json:"groupNameField,omitempty" yaml:"group_name_field,omitempty"`
+
+	GroupObjectClass string `json:"groupObjectClass,omitempty" yaml:"group_object_class,omitempty"`
+
+	GroupSearchDomain string `json:"groupSearchDomain,omitempty" yaml:"group_search_domain,omitempty"`
+
+	GroupSearchField string `json:"groupSearchField,omitempty" yaml:"group_search_field,omitempty"`
+
+	LoginDomain string `json:"loginDomain,omitempty" yaml:"login_domain,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Port int64 `json:"port,omitempty" yaml:"port,omitempty"`
+
+	Server string `json:"server,omitempty" yaml:"server,omitempty"`
+
+	ServiceAccountPassword string `json:"serviceAccountPassword,omitempty" yaml:"service_account_password,omitempty"`
+
+	ServiceAccountUsername string `json:"serviceAccountUsername,omitempty" yaml:"service_account_username,omitempty"`
+
+	Tls bool `json:"tls,omitempty" yaml:"tls,omitempty"`
+
+	UserDisabledBitMask int64 `json:"userDisabledBitMask,omitempty" yaml:"user_disabled_bit_mask,omitempty"`
+
+	UserEnabledAttribute string `json:"userEnabledAttribute,omitempty" yaml:"user_enabled_attribute,omitempty"`
+
+	UserLoginField string `json:"userLoginField,omitempty" yaml:"user_login_field,omitempty"`
+
+	UserMemberAttribute string `json:"userMemberAttribute,omitempty" yaml:"user_member_attribute,omitempty"`
+
+	UserNameField string `json:"userNameField,omitempty" yaml:"user_name_field,omitempty"`
+
+	UserObjectClass string `json:"userObjectClass,omitempty" yaml:"user_object_class,omitempty"`
+
+	UserSearchField string `json:"userSearchField,omitempty" yaml:"user_search_field,omitempty"`
+}
+
+type OpenldapconfigCollection struct {
+	Collection
+	Data   []Openldapconfig `json:"data,omitempty"`
+	client *OpenldapconfigClient
+}
+
+type OpenldapconfigClient struct {
+	rancherClient *RancherClient
+}
+
+type OpenldapconfigOperations interface {
+	List(opts *ListOpts) (*OpenldapconfigCollection, error)
+	Create(opts *Openldapconfig) (*Openldapconfig, error)
+	Update(existing *Openldapconfig, updates interface{}) (*Openldapconfig, error)
+	ById(id string) (*Openldapconfig, error)
+	Delete(container *Openldapconfig) error
+}
+
+func newOpenldapconfigClient(rancherClient *RancherClient) *OpenldapconfigClient {
+	return &OpenldapconfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *OpenldapconfigClient) Create(container *Openldapconfig) (*Openldapconfig, error) {
+	resp := &Openldapconfig{}
+	err := c.rancherClient.doCreate(OPENLDAPCONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *OpenldapconfigClient) Update(existing *Openldapconfig, updates interface{}) (*Openldapconfig, error) {
+	resp := &Openldapconfig{}
+	err := c.rancherClient.doUpdate(OPENLDAPCONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *OpenldapconfigClient) List(opts *ListOpts) (*OpenldapconfigCollection, error) {
+	resp := &OpenldapconfigCollection{}
+	err := c.rancherClient.doList(OPENLDAPCONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *OpenldapconfigCollection) Next() (*OpenldapconfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &OpenldapconfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *OpenldapconfigClient) ById(id string) (*Openldapconfig, error) {
+	resp := &Openldapconfig{}
+	err := c.rancherClient.doById(OPENLDAPCONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *OpenldapconfigClient) Delete(container *Openldapconfig) error {
+	return c.rancherClient.doResourceDelete(OPENLDAPCONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_packet_config.go

@@ -0,0 +1,89 @@
+package client
+
+const (
+	PACKET_CONFIG_TYPE = "packetConfig"
+)
+
+type PacketConfig struct {
+	Resource
+
+	ApiKey string `json:"apiKey,omitempty" yaml:"api_key,omitempty"`
+
+	BillingCycle string `json:"billingCycle,omitempty" yaml:"billing_cycle,omitempty"`
+
+	FacilityCode string `json:"facilityCode,omitempty" yaml:"facility_code,omitempty"`
+
+	Os string `json:"os,omitempty" yaml:"os,omitempty"`
+
+	Plan string `json:"plan,omitempty" yaml:"plan,omitempty"`
+
+	ProjectId string `json:"projectId,omitempty" yaml:"project_id,omitempty"`
+}
+
+type PacketConfigCollection struct {
+	Collection
+	Data   []PacketConfig `json:"data,omitempty"`
+	client *PacketConfigClient
+}
+
+type PacketConfigClient struct {
+	rancherClient *RancherClient
+}
+
+type PacketConfigOperations interface {
+	List(opts *ListOpts) (*PacketConfigCollection, error)
+	Create(opts *PacketConfig) (*PacketConfig, error)
+	Update(existing *PacketConfig, updates interface{}) (*PacketConfig, error)
+	ById(id string) (*PacketConfig, error)
+	Delete(container *PacketConfig) error
+}
+
+func newPacketConfigClient(rancherClient *RancherClient) *PacketConfigClient {
+	return &PacketConfigClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *PacketConfigClient) Create(container *PacketConfig) (*PacketConfig, error) {
+	resp := &PacketConfig{}
+	err := c.rancherClient.doCreate(PACKET_CONFIG_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *PacketConfigClient) Update(existing *PacketConfig, updates interface{}) (*PacketConfig, error) {
+	resp := &PacketConfig{}
+	err := c.rancherClient.doUpdate(PACKET_CONFIG_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *PacketConfigClient) List(opts *ListOpts) (*PacketConfigCollection, error) {
+	resp := &PacketConfigCollection{}
+	err := c.rancherClient.doList(PACKET_CONFIG_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *PacketConfigCollection) Next() (*PacketConfigCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &PacketConfigCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *PacketConfigClient) ById(id string) (*PacketConfig, error) {
+	resp := &PacketConfig{}
+	err := c.rancherClient.doById(PACKET_CONFIG_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *PacketConfigClient) Delete(container *PacketConfig) error {
+	return c.rancherClient.doResourceDelete(PACKET_CONFIG_TYPE, &container.Resource)
+}

vendor/github.com/rancher/go-rancher/v2/generated_password.go

@@ -0,0 +1,184 @@
+package client
+
+const (
+	PASSWORD_TYPE = "password"
+)
+
+type Password struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PublicValue string `json:"publicValue,omitempty" yaml:"public_value,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	SecretValue string `json:"secretValue,omitempty" yaml:"secret_value,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type PasswordCollection struct {
+	Collection
+	Data   []Password `json:"data,omitempty"`
+	client *PasswordClient
+}
+
+type PasswordClient struct {
+	rancherClient *RancherClient
+}
+
+type PasswordOperations interface {
+	List(opts *ListOpts) (*PasswordCollection, error)
+	Create(opts *Password) (*Password, error)
+	Update(existing *Password, updates interface{}) (*Password, error)
+	ById(id string) (*Password, error)
+	Delete(container *Password) error
+
+	ActionActivate(*Password) (*Credential, error)
+
+	ActionChangesecret(*Password, *ChangeSecretInput) (*ChangeSecretInput, error)
+
+	ActionCreate(*Password) (*Credential, error)
+
+	ActionDeactivate(*Password) (*Credential, error)
+
+	ActionPurge(*Password) (*Credential, error)
+
+	ActionRemove(*Password) (*Credential, error)
+
+	ActionUpdate(*Password) (*Credential, error)
+}
+
+func newPasswordClient(rancherClient *RancherClient) *PasswordClient {
+	return &PasswordClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *PasswordClient) Create(container *Password) (*Password, error) {
+	resp := &Password{}
+	err := c.rancherClient.doCreate(PASSWORD_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *PasswordClient) Update(existing *Password, updates interface{}) (*Password, error) {
+	resp := &Password{}
+	err := c.rancherClient.doUpdate(PASSWORD_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *PasswordClient) List(opts *ListOpts) (*PasswordCollection, error) {
+	resp := &PasswordCollection{}
+	err := c.rancherClient.doList(PASSWORD_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *PasswordCollection) Next() (*PasswordCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &PasswordCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *PasswordClient) ById(id string) (*Password, error) {
+	resp := &Password{}
+	err := c.rancherClient.doById(PASSWORD_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *PasswordClient) Delete(container *Password) error {
+	return c.rancherClient.doResourceDelete(PASSWORD_TYPE, &container.Resource)
+}
+
+func (c *PasswordClient) ActionActivate(resource *Password) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(PASSWORD_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PasswordClient) ActionChangesecret(resource *Password, input *ChangeSecretInput) (*ChangeSecretInput, error) {
+
+	resp := &ChangeSecretInput{}
+
+	err := c.rancherClient.doAction(PASSWORD_TYPE, "changesecret", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *PasswordClient) ActionCreate(resource *Password) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(PASSWORD_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PasswordClient) ActionDeactivate(resource *Password) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(PASSWORD_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PasswordClient) ActionPurge(resource *Password) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(PASSWORD_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PasswordClient) ActionRemove(resource *Password) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(PASSWORD_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PasswordClient) ActionUpdate(resource *Password) (*Credential, error) {
+
+	resp := &Credential{}
+
+	err := c.rancherClient.doAction(PASSWORD_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_physical_host.go

@@ -0,0 +1,162 @@
+package client
+
+const (
+	PHYSICAL_HOST_TYPE = "physicalHost"
+)
+
+type PhysicalHost struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	Driver string `json:"driver,omitempty" yaml:"driver,omitempty"`
+
+	ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type PhysicalHostCollection struct {
+	Collection
+	Data   []PhysicalHost `json:"data,omitempty"`
+	client *PhysicalHostClient
+}
+
+type PhysicalHostClient struct {
+	rancherClient *RancherClient
+}
+
+type PhysicalHostOperations interface {
+	List(opts *ListOpts) (*PhysicalHostCollection, error)
+	Create(opts *PhysicalHost) (*PhysicalHost, error)
+	Update(existing *PhysicalHost, updates interface{}) (*PhysicalHost, error)
+	ById(id string) (*PhysicalHost, error)
+	Delete(container *PhysicalHost) error
+
+	ActionBootstrap(*PhysicalHost) (*PhysicalHost, error)
+
+	ActionCreate(*PhysicalHost) (*PhysicalHost, error)
+
+	ActionError(*PhysicalHost) (*PhysicalHost, error)
+
+	ActionRemove(*PhysicalHost) (*PhysicalHost, error)
+
+	ActionUpdate(*PhysicalHost) (*PhysicalHost, error)
+}
+
+func newPhysicalHostClient(rancherClient *RancherClient) *PhysicalHostClient {
+	return &PhysicalHostClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *PhysicalHostClient) Create(container *PhysicalHost) (*PhysicalHost, error) {
+	resp := &PhysicalHost{}
+	err := c.rancherClient.doCreate(PHYSICAL_HOST_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *PhysicalHostClient) Update(existing *PhysicalHost, updates interface{}) (*PhysicalHost, error) {
+	resp := &PhysicalHost{}
+	err := c.rancherClient.doUpdate(PHYSICAL_HOST_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *PhysicalHostClient) List(opts *ListOpts) (*PhysicalHostCollection, error) {
+	resp := &PhysicalHostCollection{}
+	err := c.rancherClient.doList(PHYSICAL_HOST_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *PhysicalHostCollection) Next() (*PhysicalHostCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &PhysicalHostCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *PhysicalHostClient) ById(id string) (*PhysicalHost, error) {
+	resp := &PhysicalHost{}
+	err := c.rancherClient.doById(PHYSICAL_HOST_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *PhysicalHostClient) Delete(container *PhysicalHost) error {
+	return c.rancherClient.doResourceDelete(PHYSICAL_HOST_TYPE, &container.Resource)
+}
+
+func (c *PhysicalHostClient) ActionBootstrap(resource *PhysicalHost) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(PHYSICAL_HOST_TYPE, "bootstrap", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PhysicalHostClient) ActionCreate(resource *PhysicalHost) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(PHYSICAL_HOST_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PhysicalHostClient) ActionError(resource *PhysicalHost) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(PHYSICAL_HOST_TYPE, "error", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PhysicalHostClient) ActionRemove(resource *PhysicalHost) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(PHYSICAL_HOST_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PhysicalHostClient) ActionUpdate(resource *PhysicalHost) (*PhysicalHost, error) {
+
+	resp := &PhysicalHost{}
+
+	err := c.rancherClient.doAction(PHYSICAL_HOST_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}

vendor/github.com/rancher/go-rancher/v2/generated_port.go

@@ -0,0 +1,183 @@
+package client
+
+const (
+	PORT_TYPE = "port"
+)
+
+type Port struct {
+	Resource
+
+	AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
+
+	BindAddress string `json:"bindAddress,omitempty" yaml:"bind_address,omitempty"`
+
+	Created string `json:"created,omitempty" yaml:"created,omitempty"`
+
+	Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
+
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+
+	InstanceId string `json:"instanceId,omitempty" yaml:"instance_id,omitempty"`
+
+	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
+
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	PrivateIpAddressId string `json:"privateIpAddressId,omitempty" yaml:"private_ip_address_id,omitempty"`
+
+	PrivatePort int64 `json:"privatePort,omitempty" yaml:"private_port,omitempty"`
+
+	Protocol string `json:"protocol,omitempty" yaml:"protocol,omitempty"`
+
+	PublicIpAddressId string `json:"publicIpAddressId,omitempty" yaml:"public_ip_address_id,omitempty"`
+
+	PublicPort int64 `json:"publicPort,omitempty" yaml:"public_port,omitempty"`
+
+	RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
+
+	Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
+
+	State string `json:"state,omitempty" yaml:"state,omitempty"`
+
+	Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
+
+	TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
+
+	TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
+
+	Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
+}
+
+type PortCollection struct {
+	Collection
+	Data   []Port `json:"data,omitempty"`
+	client *PortClient
+}
+
+type PortClient struct {
+	rancherClient *RancherClient
+}
+
+type PortOperations interface {
+	List(opts *ListOpts) (*PortCollection, error)
+	Create(opts *Port) (*Port, error)
+	Update(existing *Port, updates interface{}) (*Port, error)
+	ById(id string) (*Port, error)
+	Delete(container *Port) error
+
+	ActionActivate(*Port) (*Port, error)
+
+	ActionCreate(*Port) (*Port, error)
+
+	ActionDeactivate(*Port) (*Port, error)
+
+	ActionPurge(*Port) (*Port, error)
+
+	ActionRemove(*Port) (*Port, error)
+
+	ActionUpdate(*Port) (*Port, error)
+}
+
+func newPortClient(rancherClient *RancherClient) *PortClient {
+	return &PortClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *PortClient) Create(container *Port) (*Port, error) {
+	resp := &Port{}
+	err := c.rancherClient.doCreate(PORT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *PortClient) Update(existing *Port, updates interface{}) (*Port, error) {
+	resp := &Port{}
+	err := c.rancherClient.doUpdate(PORT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *PortClient) List(opts *ListOpts) (*PortCollection, error) {
+	resp := &PortCollection{}
+	err := c.rancherClient.doList(PORT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *PortCollection) Next() (*PortCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &PortCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *PortClient) ById(id string) (*Port, error) {
+	resp := &Port{}
+	err := c.rancherClient.doById(PORT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *PortClient) Delete(container *Port) error {
+	return c.rancherClient.doResourceDelete(PORT_TYPE, &container.Resource)
+}
+
+func (c *PortClient) ActionActivate(resource *Port) (*Port, error) {
+
+	resp := &Port{}
+
+	err := c.rancherClient.doAction(PORT_TYPE, "activate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PortClient) ActionCreate(resource *Port) (*Port, error) {
+
+	resp := &Port{}
+
+	err := c.rancherClient.doAction(PORT_TYPE, "create", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PortClient) ActionDeactivate(resource *Port) (*Port, error) {
+
+	resp := &Port{}
+
+	err := c.rancherClient.doAction(PORT_TYPE, "deactivate", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PortClient) ActionPurge(resource *Port) (*Port, error) {
+
+	resp := &Port{}
+
+	err := c.rancherClient.doAction(PORT_TYPE, "purge", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PortClient) ActionRemove(resource *Port) (*Port, error) {
+
+	resp := &Port{}
+
+	err := c.rancherClient.doAction(PORT_TYPE, "remove", &resource.Resource, nil, resp)
+
+	return resp, err
+}
+
+func (c *PortClient) ActionUpdate(resource *Port) (*Port, error) {
+
+	resp := &Port{}
+
+	err := c.rancherClient.doAction(PORT_TYPE, "update", &resource.Resource, nil, resp)
+
+	return resp, err
+}