api_linode_instances.go

/*
Linode API

[Read the API documentation](https://techdocs.akamai.com/linode-api/reference/api).

API version: 4.189.2
Contact: support@linode.com
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package openapi

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"strings"
)


// LinodeInstancesAPIService LinodeInstancesAPI service
type LinodeInstancesAPIService service

type ApiDeleteDiskRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	diskId int32
}

func (r ApiDeleteDiskRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.DeleteDiskExecute(r)
}

/*
DeleteDisk Delete a disk

Deletes a Disk you have permission to `read_write`.

__Deleting a Disk is a destructive action and cannot be undone.__


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disk-delete 123 24674
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param diskId ID of the Disk to look up.
 @return ApiDeleteDiskRequest
*/
func (a *LinodeInstancesAPIService) DeleteDisk(ctx context.Context, apiVersion string, linodeId int32, diskId int32) ApiDeleteDiskRequest {
	return ApiDeleteDiskRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		diskId: diskId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) DeleteDiskExecute(r ApiDeleteDiskRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.DeleteDisk")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks/{diskId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"diskId"+"}", url.PathEscape(parameterValueToString(r.diskId, "diskId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDeleteLinodeConfigRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
}

func (r ApiDeleteLinodeConfigRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.DeleteLinodeConfigExecute(r)
}

/*
DeleteLinodeConfig Delete a config profile

Deletes the specified Configuration profile from the specified Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-delete 123 23456
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @return ApiDeleteLinodeConfigRequest
*/
func (a *LinodeInstancesAPIService) DeleteLinodeConfig(ctx context.Context, apiVersion string, linodeId int32, configId int32) ApiDeleteLinodeConfigRequest {
	return ApiDeleteLinodeConfigRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) DeleteLinodeConfigExecute(r ApiDeleteLinodeConfigRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.DeleteLinodeConfig")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDeleteLinodeConfigInterfaceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
	interfaceId int32
}

func (r ApiDeleteLinodeConfigInterfaceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.DeleteLinodeConfigInterfaceExecute(r)
}

/*
DeleteLinodeConfigInterface Delete a configuration profile interface

Deletes an Interface from the Configuration Profile.

- The User accessing this operation must have `read_write` grants to the Linode.
- A successful request triggers a `linode_config_update` event.
- Active Interfaces cannot be deleted. The associated Linode must first be shut down (or restarted using another Configuration Profile) before such Interfaces can be deleted from a Configuration Profile.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-interface-delete $linodeId $configId $interfaceId
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @param interfaceId The `id` of the Linode Configuration Profile Interface.
 @return ApiDeleteLinodeConfigInterfaceRequest
*/
func (a *LinodeInstancesAPIService) DeleteLinodeConfigInterface(ctx context.Context, apiVersion string, linodeId int32, configId int32, interfaceId int32) ApiDeleteLinodeConfigInterfaceRequest {
	return ApiDeleteLinodeConfigInterfaceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
		interfaceId: interfaceId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) DeleteLinodeConfigInterfaceExecute(r ApiDeleteLinodeConfigInterfaceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.DeleteLinodeConfigInterface")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}/interfaces/{interfaceId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"interfaceId"+"}", url.PathEscape(parameterValueToString(r.interfaceId, "interfaceId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDeleteLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiDeleteLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.DeleteLinodeInstanceExecute(r)
}

/*
DeleteLinodeInstance Delete a Linode

Deletes a Linode you have permission to `read_write`.

__Deleting a Linode is a destructive action and cannot be undone.__

Additionally, deleting a Linode:

  - Gives up any IP addresses the Linode was assigned.
  - Deletes all Disks, Backups, Configs, etc.
  - Detaches any Volumes associated with the Linode.
  - Stops billing for the Linode and its associated services. You will be billed for time used within the billing period the Linode was active.

Linodes that are in the process of [cloning](https://techdocs.akamai.com/linode-api/reference/post-clone-linode-instance) or [backup restoration](https://techdocs.akamai.com/linode-api/reference/post-restore-backup) cannot be deleted.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes delete 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiDeleteLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) DeleteLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiDeleteLinodeInstanceRequest {
	return ApiDeleteLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) DeleteLinodeInstanceExecute(r ApiDeleteLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.DeleteLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDeleteLinodeIpRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	address string
}

func (r ApiDeleteLinodeIpRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.DeleteLinodeIpExecute(r)
}

/*
DeleteLinodeIp Delete an IPv4 address

Deletes a public or private IPv4 address associated with this Linode. This will fail if it is the Linode's last remaining public IPv4 address, or if the address has a 1:1 NAT with an active VPC Subnet address.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes ip-delete 97.107.143.141
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode.
 @param address The IP address.
 @return ApiDeleteLinodeIpRequest
*/
func (a *LinodeInstancesAPIService) DeleteLinodeIp(ctx context.Context, apiVersion string, linodeId int32, address string) ApiDeleteLinodeIpRequest {
	return ApiDeleteLinodeIpRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		address: address,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) DeleteLinodeIpExecute(r ApiDeleteLinodeIpRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.DeleteLinodeIp")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/ips/{address}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"address"+"}", url.PathEscape(parameterValueToString(r.address, "address")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetBackupRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	backupId int32
}

func (r ApiGetBackupRequest) Execute() (*GetBackups200ResponseSnapshotCurrent, *http.Response, error) {
	return r.ApiService.GetBackupExecute(r)
}

/*
GetBackup Get a backup

Returns information about a Backup.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes backup-view 123 123456
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode the Backup belongs to.
 @param backupId The ID of the Backup to look up.
 @return ApiGetBackupRequest
*/
func (a *LinodeInstancesAPIService) GetBackup(ctx context.Context, apiVersion string, linodeId int32, backupId int32) ApiGetBackupRequest {
	return ApiGetBackupRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		backupId: backupId,
	}
}

// Execute executes the request
//  @return GetBackups200ResponseSnapshotCurrent
func (a *LinodeInstancesAPIService) GetBackupExecute(r ApiGetBackupRequest) (*GetBackups200ResponseSnapshotCurrent, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetBackups200ResponseSnapshotCurrent
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetBackup")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/backups/{backupId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"backupId"+"}", url.PathEscape(parameterValueToString(r.backupId, "backupId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetBackupsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiGetBackupsRequest) Execute() (*GetBackups200Response, *http.Response, error) {
	return r.ApiService.GetBackupsExecute(r)
}

/*
GetBackups List backups

Returns information about this Linode's available backups.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes backups-list 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode the backups belong to.
 @return ApiGetBackupsRequest
*/
func (a *LinodeInstancesAPIService) GetBackups(ctx context.Context, apiVersion string, linodeId int32) ApiGetBackupsRequest {
	return ApiGetBackupsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetBackups200Response
func (a *LinodeInstancesAPIService) GetBackupsExecute(r ApiGetBackupsRequest) (*GetBackups200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetBackups200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetBackups")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/backups"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetKernelRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	kernelId string
}

func (r ApiGetKernelRequest) Execute() (*GetKernels200ResponseDataInner, *http.Response, error) {
	return r.ApiService.GetKernelExecute(r)
}

/*
GetKernel Get a kernel

Returns information about a single Kernel.


<<LB>>

---


- __CLI__.

    ```
    linode-cli kernels view latest-64bit
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param kernelId ID of the Kernel to look up.
 @return ApiGetKernelRequest
*/
func (a *LinodeInstancesAPIService) GetKernel(ctx context.Context, apiVersion string, kernelId string) ApiGetKernelRequest {
	return ApiGetKernelRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		kernelId: kernelId,
	}
}

// Execute executes the request
//  @return GetKernels200ResponseDataInner
func (a *LinodeInstancesAPIService) GetKernelExecute(r ApiGetKernelRequest) (*GetKernels200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetKernels200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetKernel")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/kernels/{kernelId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"kernelId"+"}", url.PathEscape(parameterValueToString(r.kernelId, "kernelId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetKernelsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	page *int32
	pageSize *int32
}

// The page of a collection to return.
func (r ApiGetKernelsRequest) Page(page int32) ApiGetKernelsRequest {
	r.page = &page
	return r
}

// The number of items to return per page.
func (r ApiGetKernelsRequest) PageSize(pageSize int32) ApiGetKernelsRequest {
	r.pageSize = &pageSize
	return r
}

func (r ApiGetKernelsRequest) Execute() (*GetKernels200Response, *http.Response, error) {
	return r.ApiService.GetKernelsExecute(r)
}

/*
GetKernels List kernels

Lists available Kernels.

Due to the extensive list of available kernels, please keep [pagination](https://techdocs.akamai.com/linode-api/reference/pagination) controls in mind when managing responses to this operation.


<<LB>>

---


- __CLI__.

    ```
    linode-cli kernels list
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @return ApiGetKernelsRequest
*/
func (a *LinodeInstancesAPIService) GetKernels(ctx context.Context, apiVersion string) ApiGetKernelsRequest {
	return ApiGetKernelsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
	}
}

// Execute executes the request
//  @return GetKernels200Response
func (a *LinodeInstancesAPIService) GetKernelsExecute(r ApiGetKernelsRequest) (*GetKernels200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetKernels200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetKernels")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/kernels"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
	} else {
		var defaultValue int32 = 1
		r.page = &defaultValue
	}
	if r.pageSize != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
	} else {
		var defaultValue int32 = 100
		r.pageSize = &defaultValue
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeConfigRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
}

func (r ApiGetLinodeConfigRequest) Execute() (*GetLinodeConfigs200ResponseDataInner, *http.Response, error) {
	return r.ApiService.GetLinodeConfigExecute(r)
}

/*
GetLinodeConfig Get a config profile

Returns information about a specific Configuration profile.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-view 123 23456
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @return ApiGetLinodeConfigRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeConfig(ctx context.Context, apiVersion string, linodeId int32, configId int32) ApiGetLinodeConfigRequest {
	return ApiGetLinodeConfigRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
	}
}

// Execute executes the request
//  @return GetLinodeConfigs200ResponseDataInner
func (a *LinodeInstancesAPIService) GetLinodeConfigExecute(r ApiGetLinodeConfigRequest) (*GetLinodeConfigs200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeConfigs200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeConfig")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeConfigInterfaceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
	interfaceId int32
}

func (r ApiGetLinodeConfigInterfaceRequest) Execute() (*PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	return r.ApiService.GetLinodeConfigInterfaceExecute(r)
}

/*
GetLinodeConfigInterface Get a configuration profile interface

Returns a single Configuration Profile Interface.

- The User accessing this operation must have at least `read_only` grants to the Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-interface-view $linodeId $configId $interfaceId
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @param interfaceId The `id` of the Linode Configuration Profile Interface.
 @return ApiGetLinodeConfigInterfaceRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeConfigInterface(ctx context.Context, apiVersion string, linodeId int32, configId int32, interfaceId int32) ApiGetLinodeConfigInterfaceRequest {
	return ApiGetLinodeConfigInterfaceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
		interfaceId: interfaceId,
	}
}

// Execute executes the request
//  @return PostLinodeInstanceRequestAllOfInterfacesInner
func (a *LinodeInstancesAPIService) GetLinodeConfigInterfaceExecute(r ApiGetLinodeConfigInterfaceRequest) (*PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *PostLinodeInstanceRequestAllOfInterfacesInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeConfigInterface")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}/interfaces/{interfaceId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"interfaceId"+"}", url.PathEscape(parameterValueToString(r.interfaceId, "interfaceId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeConfigInterfacesRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
}

func (r ApiGetLinodeConfigInterfacesRequest) Execute() ([]PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	return r.ApiService.GetLinodeConfigInterfacesExecute(r)
}

/*
GetLinodeConfigInterfaces List configuration profile interfaces

Returns an ordered array of all Interfaces associated with this Configuration Profile.

- The User accessing this operation must have at least `read_only` grants to the Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-interfaces-list $linodeId $configId
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @return ApiGetLinodeConfigInterfacesRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeConfigInterfaces(ctx context.Context, apiVersion string, linodeId int32, configId int32) ApiGetLinodeConfigInterfacesRequest {
	return ApiGetLinodeConfigInterfacesRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
	}
}

// Execute executes the request
//  @return []PostLinodeInstanceRequestAllOfInterfacesInner
func (a *LinodeInstancesAPIService) GetLinodeConfigInterfacesExecute(r ApiGetLinodeConfigInterfacesRequest) ([]PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  []PostLinodeInstanceRequestAllOfInterfacesInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeConfigInterfaces")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}/interfaces"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeConfigsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	page *int32
	pageSize *int32
}

// The page of a collection to return.
func (r ApiGetLinodeConfigsRequest) Page(page int32) ApiGetLinodeConfigsRequest {
	r.page = &page
	return r
}

// The number of items to return per page.
func (r ApiGetLinodeConfigsRequest) PageSize(pageSize int32) ApiGetLinodeConfigsRequest {
	r.pageSize = &pageSize
	return r
}

func (r ApiGetLinodeConfigsRequest) Execute() (*GetLinodeConfigs200Response, *http.Response, error) {
	return r.ApiService.GetLinodeConfigsExecute(r)
}

/*
GetLinodeConfigs List config profiles

Lists Configuration profiles associated with a Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes configs-list 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up Configuration profiles for.
 @return ApiGetLinodeConfigsRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeConfigs(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeConfigsRequest {
	return ApiGetLinodeConfigsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeConfigs200Response
func (a *LinodeInstancesAPIService) GetLinodeConfigsExecute(r ApiGetLinodeConfigsRequest) (*GetLinodeConfigs200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeConfigs200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeConfigs")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
	} else {
		var defaultValue int32 = 1
		r.page = &defaultValue
	}
	if r.pageSize != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
	} else {
		var defaultValue int32 = 100
		r.pageSize = &defaultValue
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeDiskRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	diskId int32
}

func (r ApiGetLinodeDiskRequest) Execute() (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	return r.ApiService.GetLinodeDiskExecute(r)
}

/*
GetLinodeDisk Get a disk

View Disk information for a Disk associated with this Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disk-view 123 25674
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param diskId ID of the Disk to look up.
 @return ApiGetLinodeDiskRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeDisk(ctx context.Context, apiVersion string, linodeId int32, diskId int32) ApiGetLinodeDiskRequest {
	return ApiGetLinodeDiskRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		diskId: diskId,
	}
}

// Execute executes the request
//  @return GetLinodeDisks200ResponseDataInner
func (a *LinodeInstancesAPIService) GetLinodeDiskExecute(r ApiGetLinodeDiskRequest) (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeDisks200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeDisk")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks/{diskId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"diskId"+"}", url.PathEscape(parameterValueToString(r.diskId, "diskId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeDisksRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	page *int32
	pageSize *int32
}

// The page of a collection to return.
func (r ApiGetLinodeDisksRequest) Page(page int32) ApiGetLinodeDisksRequest {
	r.page = &page
	return r
}

// The number of items to return per page.
func (r ApiGetLinodeDisksRequest) PageSize(pageSize int32) ApiGetLinodeDisksRequest {
	r.pageSize = &pageSize
	return r
}

func (r ApiGetLinodeDisksRequest) Execute() (*GetLinodeDisks200Response, *http.Response, error) {
	return r.ApiService.GetLinodeDisksExecute(r)
}

/*
GetLinodeDisks List disks

View Disk information for Disks associated with this Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disks-list 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiGetLinodeDisksRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeDisks(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeDisksRequest {
	return ApiGetLinodeDisksRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeDisks200Response
func (a *LinodeInstancesAPIService) GetLinodeDisksExecute(r ApiGetLinodeDisksRequest) (*GetLinodeDisks200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeDisks200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeDisks")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
	} else {
		var defaultValue int32 = 1
		r.page = &defaultValue
	}
	if r.pageSize != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
	} else {
		var defaultValue int32 = 100
		r.pageSize = &defaultValue
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeFirewallsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	page *int32
	pageSize *int32
}

// The page of a collection to return.
func (r ApiGetLinodeFirewallsRequest) Page(page int32) ApiGetLinodeFirewallsRequest {
	r.page = &page
	return r
}

// The number of items to return per page.
func (r ApiGetLinodeFirewallsRequest) PageSize(pageSize int32) ApiGetLinodeFirewallsRequest {
	r.pageSize = &pageSize
	return r
}

func (r ApiGetLinodeFirewallsRequest) Execute() (*GetLinodeFirewalls200Response, *http.Response, error) {
	return r.ApiService.GetLinodeFirewallsExecute(r)
}

/*
GetLinodeFirewalls List a Linode's firewalls

View Firewall information for Firewalls assigned to this Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes firewalls-list 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to access.
 @return ApiGetLinodeFirewallsRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeFirewalls(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeFirewallsRequest {
	return ApiGetLinodeFirewallsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeFirewalls200Response
func (a *LinodeInstancesAPIService) GetLinodeFirewallsExecute(r ApiGetLinodeFirewallsRequest) (*GetLinodeFirewalls200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeFirewalls200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeFirewalls")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/firewalls"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
	} else {
		var defaultValue int32 = 1
		r.page = &defaultValue
	}
	if r.pageSize != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
	} else {
		var defaultValue int32 = 100
		r.pageSize = &defaultValue
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiGetLinodeInstanceRequest) Execute() (*Linode, *http.Response, error) {
	return r.ApiService.GetLinodeInstanceExecute(r)
}

/*
GetLinodeInstance Get a Linode

Get a specific Linode by ID.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes view 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiGetLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeInstanceRequest {
	return ApiGetLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return Linode
func (a *LinodeInstancesAPIService) GetLinodeInstanceExecute(r ApiGetLinodeInstanceRequest) (*Linode, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *Linode
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeInstancesRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	xFilter *GetLinodeInstancesXFilterParameter
	page *int32
	pageSize *int32
}

// Specifies a JSON object to filter down the results. See [Filtering and sorting](filtering-and-sorting) for details.
func (r ApiGetLinodeInstancesRequest) XFilter(xFilter GetLinodeInstancesXFilterParameter) ApiGetLinodeInstancesRequest {
	r.xFilter = &xFilter
	return r
}

// The page of a collection to return.
func (r ApiGetLinodeInstancesRequest) Page(page int32) ApiGetLinodeInstancesRequest {
	r.page = &page
	return r
}

// The number of items to return per page.
func (r ApiGetLinodeInstancesRequest) PageSize(pageSize int32) ApiGetLinodeInstancesRequest {
	r.pageSize = &pageSize
	return r
}

func (r ApiGetLinodeInstancesRequest) Execute() (*GetLinodeInstances200Response, *http.Response, error) {
	return r.ApiService.GetLinodeInstancesExecute(r)
}

/*
GetLinodeInstances List Linodes

Returns a paginated list of Linodes you have permission to view.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes list
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @return ApiGetLinodeInstancesRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeInstances(ctx context.Context, apiVersion string) ApiGetLinodeInstancesRequest {
	return ApiGetLinodeInstancesRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
	}
}

// Execute executes the request
//  @return GetLinodeInstances200Response
func (a *LinodeInstancesAPIService) GetLinodeInstancesExecute(r ApiGetLinodeInstancesRequest) (*GetLinodeInstances200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeInstances200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeInstances")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
	} else {
		var defaultValue int32 = 1
		r.page = &defaultValue
	}
	if r.pageSize != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
	} else {
		var defaultValue int32 = 100
		r.pageSize = &defaultValue
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xFilter != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "X-Filter", r.xFilter, "simple", "")
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeIpRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	address string
}

func (r ApiGetLinodeIpRequest) Execute() (*GetLinodeIps200ResponseIpv4PublicInner, *http.Response, error) {
	return r.ApiService.GetLinodeIpExecute(r)
}

/*
GetLinodeIp Get a Linode's IP address

View information about the specified IP address associated with the specified Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes ip-view 123 97.107.143.141
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode.
 @param address The IP address.
 @return ApiGetLinodeIpRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeIp(ctx context.Context, apiVersion string, linodeId int32, address string) ApiGetLinodeIpRequest {
	return ApiGetLinodeIpRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		address: address,
	}
}

// Execute executes the request
//  @return GetLinodeIps200ResponseIpv4PublicInner
func (a *LinodeInstancesAPIService) GetLinodeIpExecute(r ApiGetLinodeIpRequest) (*GetLinodeIps200ResponseIpv4PublicInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeIps200ResponseIpv4PublicInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeIp")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/ips/{address}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"address"+"}", url.PathEscape(parameterValueToString(r.address, "address")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeIpsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiGetLinodeIpsRequest) Execute() (*GetLinodeIps200Response, *http.Response, error) {
	return r.ApiService.GetLinodeIpsExecute(r)
}

/*
GetLinodeIps Get networking information

Returns networking information for a single Linode.

__Note__. If the target Linode has several configuration profiles that include a Virtual Private Cloud (VPC) interface, address information for all of VPCs will be listed in the response.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes ips-list 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiGetLinodeIpsRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeIps(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeIpsRequest {
	return ApiGetLinodeIpsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeIps200Response
func (a *LinodeInstancesAPIService) GetLinodeIpsExecute(r ApiGetLinodeIpsRequest) (*GetLinodeIps200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeIps200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeIps")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/ips"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeNodeBalancersRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiGetLinodeNodeBalancersRequest) Execute() (*GetLinodeNodeBalancers200Response, *http.Response, error) {
	return r.ApiService.GetLinodeNodeBalancersExecute(r)
}

/*
GetLinodeNodeBalancers List Linode NodeBalancers

Returns a list of NodeBalancers that are assigned to this Linode and readable by the requesting User.

Read permission to a NodeBalancer can be given to a User by accessing the [Update a user's grants](https://techdocs.akamai.com/linode-api/reference/put-user-grants) operation.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes nodebalancers 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiGetLinodeNodeBalancersRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeNodeBalancers(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeNodeBalancersRequest {
	return ApiGetLinodeNodeBalancersRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeNodeBalancers200Response
func (a *LinodeInstancesAPIService) GetLinodeNodeBalancersExecute(r ApiGetLinodeNodeBalancersRequest) (*GetLinodeNodeBalancers200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeNodeBalancers200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeNodeBalancers")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/nodebalancers"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeStatsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiGetLinodeStatsRequest) Execute() (*GetLinodeStats200Response, *http.Response, error) {
	return r.ApiService.GetLinodeStatsExecute(r)
}

/*
GetLinodeStats Get Linode statistics

Returns CPU, IO, IPv4, and IPv6 statistics for your Linode for the past 24 hours.


<<LB>>

---


- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiGetLinodeStatsRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeStats(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeStatsRequest {
	return ApiGetLinodeStatsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeStats200Response
func (a *LinodeInstancesAPIService) GetLinodeStatsExecute(r ApiGetLinodeStatsRequest) (*GetLinodeStats200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeStats200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeStats")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/stats"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeStatsByYearMonthRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	year int32
	month int32
}

func (r ApiGetLinodeStatsByYearMonthRequest) Execute() (*GetLinodeStats200Response, *http.Response, error) {
	return r.ApiService.GetLinodeStatsByYearMonthExecute(r)
}

/*
GetLinodeStatsByYearMonth Get monthly statistics

Returns statistics for a specific month. The year/month values must be either a date in the past, or the current month. If the current month, statistics will be retrieved for the past 30 days.


<<LB>>

---


- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param year Numeric value representing the year to look up.
 @param month Numeric value representing the month to look up.
 @return ApiGetLinodeStatsByYearMonthRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeStatsByYearMonth(ctx context.Context, apiVersion string, linodeId int32, year int32, month int32) ApiGetLinodeStatsByYearMonthRequest {
	return ApiGetLinodeStatsByYearMonthRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		year: year,
		month: month,
	}
}

// Execute executes the request
//  @return GetLinodeStats200Response
func (a *LinodeInstancesAPIService) GetLinodeStatsByYearMonthExecute(r ApiGetLinodeStatsByYearMonthRequest) (*GetLinodeStats200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeStats200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeStatsByYearMonth")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/stats/{year}/{month}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"year"+"}", url.PathEscape(parameterValueToString(r.year, "year")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"month"+"}", url.PathEscape(parameterValueToString(r.month, "month")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.month < 1 {
		return localVarReturnValue, nil, reportError("month must be greater than 1")
	}
	if r.month > 12 {
		return localVarReturnValue, nil, reportError("month must be less than 12")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeTransferRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiGetLinodeTransferRequest) Execute() (*GetLinodeTransfer200Response, *http.Response, error) {
	return r.ApiService.GetLinodeTransferExecute(r)
}

/*
GetLinodeTransfer Get a network transfer

Returns a Linode's network transfer pool statistics for the current month.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes transfer-view 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiGetLinodeTransferRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeTransfer(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeTransferRequest {
	return ApiGetLinodeTransferRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeTransfer200Response
func (a *LinodeInstancesAPIService) GetLinodeTransferExecute(r ApiGetLinodeTransferRequest) (*GetLinodeTransfer200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeTransfer200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeTransfer")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/transfer"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeTransferByYearMonthRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	year int32
	month int32
}

func (r ApiGetLinodeTransferByYearMonthRequest) Execute() (*GetLinodeTransferByYearMonth200Response, *http.Response, error) {
	return r.ApiService.GetLinodeTransferByYearMonthExecute(r)
}

/*
GetLinodeTransferByYearMonth Get monthly network transfer stats

Returns a Linode's network transfer statistics for a specific month. The year/month values must be either a date in the past, or the current month.


<<LB>>

---


- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param year Numeric value representing the year to look up.
 @param month Numeric value representing the month to look up.
 @return ApiGetLinodeTransferByYearMonthRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeTransferByYearMonth(ctx context.Context, apiVersion string, linodeId int32, year int32, month int32) ApiGetLinodeTransferByYearMonthRequest {
	return ApiGetLinodeTransferByYearMonthRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		year: year,
		month: month,
	}
}

// Execute executes the request
//  @return GetLinodeTransferByYearMonth200Response
func (a *LinodeInstancesAPIService) GetLinodeTransferByYearMonthExecute(r ApiGetLinodeTransferByYearMonthRequest) (*GetLinodeTransferByYearMonth200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeTransferByYearMonth200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeTransferByYearMonth")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/transfer/{year}/{month}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"year"+"}", url.PathEscape(parameterValueToString(r.year, "year")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"month"+"}", url.PathEscape(parameterValueToString(r.month, "month")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.year < 2000 {
		return localVarReturnValue, nil, reportError("year must be greater than 2000")
	}
	if r.year > 2037 {
		return localVarReturnValue, nil, reportError("year must be less than 2037")
	}
	if r.month < 1 {
		return localVarReturnValue, nil, reportError("month must be greater than 1")
	}
	if r.month > 12 {
		return localVarReturnValue, nil, reportError("month must be less than 12")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeTypeRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	typeId string
}

func (r ApiGetLinodeTypeRequest) Execute() (*GetLinodeTypes200ResponseDataInner, *http.Response, error) {
	return r.ApiService.GetLinodeTypeExecute(r)
}

/*
GetLinodeType Get a type

Returns information about a specific Linode Type, including pricing and specifications. This is used when [creating](https://techdocs.akamai.com/linode-api/reference/post-linode-instance) or [resizing](https://techdocs.akamai.com/linode-api/reference/post-resize-linode-instance) Linodes.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes type-view g6-standard-2
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param typeId The ID of the Linode Type to look up.
 @return ApiGetLinodeTypeRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeType(ctx context.Context, apiVersion string, typeId string) ApiGetLinodeTypeRequest {
	return ApiGetLinodeTypeRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		typeId: typeId,
	}
}

// Execute executes the request
//  @return GetLinodeTypes200ResponseDataInner
func (a *LinodeInstancesAPIService) GetLinodeTypeExecute(r ApiGetLinodeTypeRequest) (*GetLinodeTypes200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeTypes200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeType")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/types/{typeId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"typeId"+"}", url.PathEscape(parameterValueToString(r.typeId, "typeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeTypesRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
}

func (r ApiGetLinodeTypesRequest) Execute() (*GetLinodeTypes200Response, *http.Response, error) {
	return r.ApiService.GetLinodeTypesExecute(r)
}

/*
GetLinodeTypes List types

Returns Linode Types, including pricing and specifications for each Type. Use these when [creating](https://techdocs.akamai.com/linode-api/reference/post-linode-instance) or [resizing](https://techdocs.akamai.com/linode-api/reference/post-resize-linode-instance) Linodes.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes types
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @return ApiGetLinodeTypesRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeTypes(ctx context.Context, apiVersion string) ApiGetLinodeTypesRequest {
	return ApiGetLinodeTypesRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
	}
}

// Execute executes the request
//  @return GetLinodeTypes200Response
func (a *LinodeInstancesAPIService) GetLinodeTypesExecute(r ApiGetLinodeTypesRequest) (*GetLinodeTypes200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeTypes200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeTypes")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/types"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetLinodeVolumesRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	page *int32
	pageSize *int32
}

// The page of a collection to return.
func (r ApiGetLinodeVolumesRequest) Page(page int32) ApiGetLinodeVolumesRequest {
	r.page = &page
	return r
}

// The number of items to return per page.
func (r ApiGetLinodeVolumesRequest) PageSize(pageSize int32) ApiGetLinodeVolumesRequest {
	r.pageSize = &pageSize
	return r
}

func (r ApiGetLinodeVolumesRequest) Execute() (*GetLinodeVolumes200Response, *http.Response, error) {
	return r.ApiService.GetLinodeVolumesExecute(r)
}

/*
GetLinodeVolumes List a Linode's volumes

View Block Storage Volumes attached to this Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes volumes 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_only
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiGetLinodeVolumesRequest
*/
func (a *LinodeInstancesAPIService) GetLinodeVolumes(ctx context.Context, apiVersion string, linodeId int32) ApiGetLinodeVolumesRequest {
	return ApiGetLinodeVolumesRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeVolumes200Response
func (a *LinodeInstancesAPIService) GetLinodeVolumesExecute(r ApiGetLinodeVolumesRequest) (*GetLinodeVolumes200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeVolumes200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.GetLinodeVolumes")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/volumes"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
	} else {
		var defaultValue int32 = 1
		r.page = &defaultValue
	}
	if r.pageSize != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
	} else {
		var defaultValue int32 = 100
		r.pageSize = &defaultValue
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostAddLinodeConfigRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postAddLinodeConfigRequest *PostAddLinodeConfigRequest
}

// The parameters to set when creating the Configuration profile. This determines which kernel, devices, how much memory, etc. a Linode boots with.
func (r ApiPostAddLinodeConfigRequest) PostAddLinodeConfigRequest(postAddLinodeConfigRequest PostAddLinodeConfigRequest) ApiPostAddLinodeConfigRequest {
	r.postAddLinodeConfigRequest = &postAddLinodeConfigRequest
	return r
}

func (r ApiPostAddLinodeConfigRequest) Execute() (*GetLinodeConfigs200ResponseDataInner, *http.Response, error) {
	return r.ApiService.PostAddLinodeConfigExecute(r)
}

/*
PostAddLinodeConfig Create a config profile

Adds a new Configuration profile to a Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-create 7590910 \
  --label "My Config" \
  --devices.sda.disk_id 123456 \
  --devices.sdb.disk_id 123457
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up Configuration profiles for.
 @return ApiPostAddLinodeConfigRequest
*/
func (a *LinodeInstancesAPIService) PostAddLinodeConfig(ctx context.Context, apiVersion string, linodeId int32) ApiPostAddLinodeConfigRequest {
	return ApiPostAddLinodeConfigRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeConfigs200ResponseDataInner
func (a *LinodeInstancesAPIService) PostAddLinodeConfigExecute(r ApiPostAddLinodeConfigRequest) (*GetLinodeConfigs200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeConfigs200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostAddLinodeConfig")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postAddLinodeConfigRequest == nil {
		return localVarReturnValue, nil, reportError("postAddLinodeConfigRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postAddLinodeConfigRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostAddLinodeDiskRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postAddLinodeDiskRequest *PostAddLinodeDiskRequest
}

// The parameters to set when creating the Disk.
func (r ApiPostAddLinodeDiskRequest) PostAddLinodeDiskRequest(postAddLinodeDiskRequest PostAddLinodeDiskRequest) ApiPostAddLinodeDiskRequest {
	r.postAddLinodeDiskRequest = &postAddLinodeDiskRequest
	return r
}

func (r ApiPostAddLinodeDiskRequest) Execute() (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	return r.ApiService.PostAddLinodeDiskExecute(r)
}

/*
PostAddLinodeDisk Create a disk

Add a new disk to an existing Linode. You can create an empty disk to manually configure it later. You can also target a stored `image` to build the disk using a pre-configured file system.

- A Linode can have up to 50 disks.

- When creating an empty disk, you need to provide a `label` for it. If you don't include a `label`, you need to target an `image` instead.

- When you create a disk from an `image`, you need to set a `root_pass` for the disk.

- The default file system for a new disk is `ext4`. If you're creating one from an `image`, the disk inherits the file system of that `image`, is unless you specify otherwise.

- When you deploy a StackScript on a disk:

  - You can run [List StackScripts](https://techdocs.akamai.com/linode-api/reference/get-stack-scripts) to review available StackScripts.

  - You need to include a compatible `image` when creating the disk. Run [Get a StackScript](https://techdocs.akamai.com/linode-api/reference/get-stack-script) to review compatible images.

  - You should supply SSH keys for the disk's root user, using the `authorized_keys` field.

  - You can include individual users via the `authorized_users` field. Before you can add a user, it needs an SSH key assigned to its profile. See [Add an SSH key](https://techdocs.akamai.com/linode-api/reference/post-add-ssh-key) for more information.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disk-create 123 \
  --size 1300 \
  --authorized_keys "ssh-rsa AAAA_valid_public_ssh_key_123456785== user@their-computer" \
  --authorized_users "myUser" \
  --authorized_users "secondaryUser" \
  --root_pass aComplex@Password \
  --image "linode/debian9" \
  --stackscript_id 10079 \
  --stackscript_data '{"gh_username": "linode"}'
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiPostAddLinodeDiskRequest
*/
func (a *LinodeInstancesAPIService) PostAddLinodeDisk(ctx context.Context, apiVersion string, linodeId int32) ApiPostAddLinodeDiskRequest {
	return ApiPostAddLinodeDiskRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeDisks200ResponseDataInner
func (a *LinodeInstancesAPIService) PostAddLinodeDiskExecute(r ApiPostAddLinodeDiskRequest) (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeDisks200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostAddLinodeDisk")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postAddLinodeDiskRequest == nil {
		return localVarReturnValue, nil, reportError("postAddLinodeDiskRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postAddLinodeDiskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostAddLinodeIpRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postAddLinodeIpRequest *PostAddLinodeIpRequest
}

// Information about the address you are creating.
func (r ApiPostAddLinodeIpRequest) PostAddLinodeIpRequest(postAddLinodeIpRequest PostAddLinodeIpRequest) ApiPostAddLinodeIpRequest {
	r.postAddLinodeIpRequest = &postAddLinodeIpRequest
	return r
}

func (r ApiPostAddLinodeIpRequest) Execute() (*GetLinodeIps200ResponseIpv4PublicInner, *http.Response, error) {
	return r.ApiService.PostAddLinodeIpExecute(r)
}

/*
PostAddLinodeIp Allocate an IPv4 address

Allocates a public or private IPv4 address to a Linode. Public IP Addresses, after the one included with each Linode, incur an additional monthly charge. If you need an additional public IP Address you must request one - please [Open a support ticket](https://techdocs.akamai.com/linode-api/reference/post-ticket). You may not add more than one private IPv4 address to a single Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes ip-add 123 \
  --type ipv4 \
  --public true
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiPostAddLinodeIpRequest
*/
func (a *LinodeInstancesAPIService) PostAddLinodeIp(ctx context.Context, apiVersion string, linodeId int32) ApiPostAddLinodeIpRequest {
	return ApiPostAddLinodeIpRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetLinodeIps200ResponseIpv4PublicInner
func (a *LinodeInstancesAPIService) PostAddLinodeIpExecute(r ApiPostAddLinodeIpRequest) (*GetLinodeIps200ResponseIpv4PublicInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeIps200ResponseIpv4PublicInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostAddLinodeIp")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/ips"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postAddLinodeIpRequest == nil {
		return localVarReturnValue, nil, reportError("postAddLinodeIpRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postAddLinodeIpRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostApplyFirewallsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiPostApplyFirewallsRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostApplyFirewallsExecute(r)
}

/*
PostApplyFirewalls Apply a Linode's firewalls

Reapply assigned firewalls to a Linode in case they were not applied successfully.

The `firewall_apply` event indicates if the firewalls were applied.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes apply-firewalls 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode.
 @return ApiPostApplyFirewallsRequest
*/
func (a *LinodeInstancesAPIService) PostApplyFirewalls(ctx context.Context, apiVersion string, linodeId int32) ApiPostApplyFirewallsRequest {
	return ApiPostApplyFirewallsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostApplyFirewallsExecute(r ApiPostApplyFirewallsRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostApplyFirewalls")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/firewalls/apply"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostBootLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postBootLinodeInstanceRequest *PostBootLinodeInstanceRequest
}

// Optional configuration to boot into (see above).
func (r ApiPostBootLinodeInstanceRequest) PostBootLinodeInstanceRequest(postBootLinodeInstanceRequest PostBootLinodeInstanceRequest) ApiPostBootLinodeInstanceRequest {
	r.postBootLinodeInstanceRequest = &postBootLinodeInstanceRequest
	return r
}

func (r ApiPostBootLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostBootLinodeInstanceExecute(r)
}

/*
PostBootLinodeInstance Boot a Linode

Boots a Linode you have permission to modify. If no parameters are given, a Config profile will be chosen for this boot based on the following criteria:

- If there is only one Config profile for this Linode, it will be used.
- If there is more than one Config profile, the last booted config will be used.
- If there is more than one Config profile and none were the last to be booted (because the Linode was never booted or the last booted config was deleted) an error will be returned.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes boot 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode to boot.
 @return ApiPostBootLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostBootLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostBootLinodeInstanceRequest {
	return ApiPostBootLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostBootLinodeInstanceExecute(r ApiPostBootLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostBootLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/boot"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postBootLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostCancelBackupsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiPostCancelBackupsRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostCancelBackupsExecute(r)
}

/*
PostCancelBackups Cancel backups

Cancels the Backup service on the given Linode. Deletes all of this Linode's existing backups forever.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes backups-cancel 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode to cancel backup service for.
 @return ApiPostCancelBackupsRequest
*/
func (a *LinodeInstancesAPIService) PostCancelBackups(ctx context.Context, apiVersion string, linodeId int32) ApiPostCancelBackupsRequest {
	return ApiPostCancelBackupsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostCancelBackupsExecute(r ApiPostCancelBackupsRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostCancelBackups")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/backups/cancel"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostCloneLinodeDiskRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	diskId int32
}

func (r ApiPostCloneLinodeDiskRequest) Execute() (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	return r.ApiService.PostCloneLinodeDiskExecute(r)
}

/*
PostCloneLinodeDisk Clone a disk

Copies a disk, byte-for-byte, into a new disk on the same Linode. The operation fails if the target doesn't have enough storage space. A Linode can have up to 50 disks.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disk-clone
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param diskId ID of the Disk to clone.
 @return ApiPostCloneLinodeDiskRequest
*/
func (a *LinodeInstancesAPIService) PostCloneLinodeDisk(ctx context.Context, apiVersion string, linodeId int32, diskId int32) ApiPostCloneLinodeDiskRequest {
	return ApiPostCloneLinodeDiskRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		diskId: diskId,
	}
}

// Execute executes the request
//  @return GetLinodeDisks200ResponseDataInner
func (a *LinodeInstancesAPIService) PostCloneLinodeDiskExecute(r ApiPostCloneLinodeDiskRequest) (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeDisks200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostCloneLinodeDisk")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks/{diskId}/clone"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"diskId"+"}", url.PathEscape(parameterValueToString(r.diskId, "diskId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostCloneLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postCloneLinodeInstanceRequest *PostCloneLinodeInstanceRequest
}

// The requested state your Linode will be cloned into.
func (r ApiPostCloneLinodeInstanceRequest) PostCloneLinodeInstanceRequest(postCloneLinodeInstanceRequest PostCloneLinodeInstanceRequest) ApiPostCloneLinodeInstanceRequest {
	r.postCloneLinodeInstanceRequest = &postCloneLinodeInstanceRequest
	return r
}

func (r ApiPostCloneLinodeInstanceRequest) Execute() (*Linode1, *http.Response, error) {
	return r.ApiService.PostCloneLinodeInstanceExecute(r)
}

/*
PostCloneLinodeInstance Clone a Linode

You can clone your Linode's existing Disks or Configuration profiles to another Linode on your Account. In order for this request to complete successfully, your User must have the `add_linodes` grant. Cloning to a new Linode will incur a charge on your Account.

If cloning to an existing Linode, any actions currently running or queued must be completed first before you can clone to it.

Up to five clone operations from any given source Linode can be run concurrently. If more concurrent clones are attempted, an HTTP 400 error will be returned by this operation.

Any [tags](https://techdocs.akamai.com/linode-api/reference/get-tags) existing on the source Linode will be cloned to the target Linode.

Linodes utilizing Metadata (`"has_user_data": true`) must be cloned to a new Linode with `metadata.user_data` included with the clone request.

`vpc` details

- If the Linode you are cloning has a `vpc` purpose Interface on its active Configuration Profile that includes a 1:1 NAT, the resulting clone is configured with an `any` 1:1 NAT.
- See the [VPC documentation](https://www.linode.com/docs/products/networking/vpc/#technical-specifications) guide for its specifications and limitations.

`vlan` details

- Only Next Generation Network (NGN) data centers support VLANs. If a VLAN is attached to your Linode and you attempt clone it to a non-NGN data center, the cloning will not initiate. If a Linode cannot be cloned because of an incompatibility, you will be prompted to select a different data center or contact support.
- See the [VLANs Overview](https://www.linode.com/docs/products/networking/vlans/#technical-specifications) guide to view additional specifications and limitations.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes clone 123 \
  --linode_id 124 \
  --region us-east \
  --type g6-standard-2 \
  --label cloned-linode \
  --backups_enabled true \
  --placement_group.id 528 \
  --disks 25674 \
  --configs 23456 \
  --private_ip true \
  --metadata.user_data I2Nsb3VkLWNvbmZpZw==
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to clone.
 @return ApiPostCloneLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostCloneLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostCloneLinodeInstanceRequest {
	return ApiPostCloneLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return Linode1
func (a *LinodeInstancesAPIService) PostCloneLinodeInstanceExecute(r ApiPostCloneLinodeInstanceRequest) (*Linode1, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *Linode1
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostCloneLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/clone"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postCloneLinodeInstanceRequest == nil {
		return localVarReturnValue, nil, reportError("postCloneLinodeInstanceRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postCloneLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostEnableBackupsRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiPostEnableBackupsRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostEnableBackupsExecute(r)
}

/*
PostEnableBackups Enable backups

Enables backups for the specified Linode.

__Note__. Backups are not encrypted even when they are taken from an encrypted disk. When a backup is restored, and if encryption is enabled, the data stored on the disk is encrypted again.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes backups-enable 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode to enable backup service for.
 @return ApiPostEnableBackupsRequest
*/
func (a *LinodeInstancesAPIService) PostEnableBackups(ctx context.Context, apiVersion string, linodeId int32) ApiPostEnableBackupsRequest {
	return ApiPostEnableBackupsRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostEnableBackupsExecute(r ApiPostEnableBackupsRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostEnableBackups")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/backups/enable"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostLinodeConfigInterfaceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
	postLinodeConfigInterfaceRequest *PostLinodeConfigInterfaceRequest
}

// The Interface to add to the Configuration Profile.
func (r ApiPostLinodeConfigInterfaceRequest) PostLinodeConfigInterfaceRequest(postLinodeConfigInterfaceRequest PostLinodeConfigInterfaceRequest) ApiPostLinodeConfigInterfaceRequest {
	r.postLinodeConfigInterfaceRequest = &postLinodeConfigInterfaceRequest
	return r
}

func (r ApiPostLinodeConfigInterfaceRequest) Execute() (*PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	return r.ApiService.PostLinodeConfigInterfaceExecute(r)
}

/*
PostLinodeConfigInterface Add a configuration profile interface

Creates and appends a single Interface to the end of the `interfaces` array for an existing Configuration Profile.

- The User accessing this operation must have `read_write` grants to the Linode.
- A successful request triggers a `linode_config_update` event.
- If the new Interface is added with `"primary": true`, then any existing primary Interface is changed to `"primary": false`.

Reboot the Linode with this Configuration Profile to activate an Interface that was added with this operation.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-interface-add $linodeId $configId \
  --purpose vpc \
  --primary false \
  --subnet_id 101 \
  --ipv4.vpc "10.0.1.2" \
  --ipv4.nat_1_1 "203.0.113.2"
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @return ApiPostLinodeConfigInterfaceRequest
*/
func (a *LinodeInstancesAPIService) PostLinodeConfigInterface(ctx context.Context, apiVersion string, linodeId int32, configId int32) ApiPostLinodeConfigInterfaceRequest {
	return ApiPostLinodeConfigInterfaceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
	}
}

// Execute executes the request
//  @return PostLinodeInstanceRequestAllOfInterfacesInner
func (a *LinodeInstancesAPIService) PostLinodeConfigInterfaceExecute(r ApiPostLinodeConfigInterfaceRequest) (*PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *PostLinodeInstanceRequestAllOfInterfacesInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostLinodeConfigInterface")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}/interfaces"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postLinodeConfigInterfaceRequest == nil {
		return localVarReturnValue, nil, reportError("postLinodeConfigInterfaceRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postLinodeConfigInterfaceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostLinodeConfigInterfacesRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
	postLinodeConfigInterfacesRequest *PostLinodeConfigInterfacesRequest
}

// The desired Interface order for the Configuration Profile.
func (r ApiPostLinodeConfigInterfacesRequest) PostLinodeConfigInterfacesRequest(postLinodeConfigInterfacesRequest PostLinodeConfigInterfacesRequest) ApiPostLinodeConfigInterfacesRequest {
	r.postLinodeConfigInterfacesRequest = &postLinodeConfigInterfacesRequest
	return r
}

func (r ApiPostLinodeConfigInterfacesRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostLinodeConfigInterfacesExecute(r)
}

/*
PostLinodeConfigInterfaces Reorder configuration profile interfaces

Reorders the existing Interfaces of a Configuration Profile.

- The User accessing this operation must have `read_write` grants to the Linode.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-interfaces-order $linodeId $configId \
  --ids 101 --ids 102 --ids 103
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @return ApiPostLinodeConfigInterfacesRequest
*/
func (a *LinodeInstancesAPIService) PostLinodeConfigInterfaces(ctx context.Context, apiVersion string, linodeId int32, configId int32) ApiPostLinodeConfigInterfacesRequest {
	return ApiPostLinodeConfigInterfacesRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostLinodeConfigInterfacesExecute(r ApiPostLinodeConfigInterfacesRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostLinodeConfigInterfaces")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}/interfaces/order"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postLinodeConfigInterfacesRequest == nil {
		return localVarReturnValue, nil, reportError("postLinodeConfigInterfacesRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postLinodeConfigInterfacesRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	postLinodeInstanceRequest *PostLinodeInstanceRequest
}

// The requested initial state of a new Linode.
func (r ApiPostLinodeInstanceRequest) PostLinodeInstanceRequest(postLinodeInstanceRequest PostLinodeInstanceRequest) ApiPostLinodeInstanceRequest {
	r.postLinodeInstanceRequest = &postLinodeInstanceRequest
	return r
}

func (r ApiPostLinodeInstanceRequest) Execute() (*Linode1, *http.Response, error) {
	return r.ApiService.PostLinodeInstanceExecute(r)
}

/*
PostLinodeInstance Create a Linode

Creates a Linode Instance on your Account. In order for this request to complete successfully, your User must have the `add_linodes` grant. Creating a new Linode will incur a charge on your Account.

Linodes can be created using one of the available Types. Run [List Linode types](https://techdocs.akamai.com/linode-api/reference/get-linode-types) to get more information about each Type's specs and cost.

Linodes can be created in any one of our available Regions, which are accessible from the [List regions](https://techdocs.akamai.com/linode-api/reference/get-regions) operation.

In an effort to fight spam, Linode restricts outbound connections on ports 25, 465, and 587 on all Linodes for new accounts created after November 5th, 2019. For more information, see our guide on [Running a Mail Server](https://www.linode.com/docs/guides/running-a-mail-server/).

__Important__. You must be an unrestricted User in order to add or modify tags on Linodes.

Linodes can be created in a number of ways:

- Using a Linode Public Image distribution or a Private Image you created based on another Linode.

  - Run the [List images](https://techdocs.akamai.com/linode-api/reference/get-images) operation with authentication to view all available Images.

  - The Linode will be `running` after it completes `provisioning`.
  - A default config with two Disks, one being a 512 swap disk, is created.
    - `swap_size` can be used to customize the swap disk size.
  - Requires a `root_pass` be supplied to use for the root User's Account.
  - It is recommended to supply SSH keys for the root User using the `authorized_keys` field.
  - You may also supply a list of usernames via the `authorized_users` field.
    - These users must have an SSH Key associated with your Profile first. See the [Add an SSH key](https://techdocs.akamai.com/linode-api/reference/post-add-ssh-key)) operation for more information.

- Using cloud-init with [Metadata](https://www.linode.com/docs/products/compute/compute-instances/guides/metadata/).
  - Automate system configuration and software installation by providing a base-64 encoded [cloud-config](https://www.linode.com/docs/products/compute/compute-instances/guides/metadata-cloud-config/) file.
  - Requires a compatible Image. You can determine compatible Images by checking for `cloud-init` under `capabilities` when running [List images](https://techdocs.akamai.com/linode-api/reference/get-images).
  - Requires a compatible Region.  You can determine compatible Regions by checking for `Metadata` under `capabilities` when running [List regions](https://techdocs.akamai.com/linode-api/reference/get-regions).

- Using a StackScript.

  - Run [List StackScripts](https://techdocs.akamai.com/linode-api/reference/get-stack-scripts) for a list of available StackScripts.
  - The Linode will be `running` after it completes `provisioning`.
  - Requires a compatible Image to be supplied.
    - Run [Get a StackScript](https://techdocs.akamai.com/linode-api/reference/get-stack-script) for compatible Images.
  - Requires a `root_pass` be supplied to use for the root User's Account.
  - It is recommended to supply SSH keys for the root User using the `authorized_keys` field.
  - You may also supply a list of usernames via the `authorized_users` field.
    - These users must have an SSH Key associated with your Profile first. See [Add an SSH key](https://techdocs.akamai.com/linode-api/reference/post-add-ssh-key) for more information.

- Using one of your other Linode's backups.
  - You must create a Linode large enough to accommodate the Backup's size.
  - The Disks and Config will match that of the Linode that was backed up.
  - The `root_pass` will match that of the Linode that was backed up.

- Attached to a private VLAN.
  - Review the `interfaces` property of the [Request Body Schema](https://techdocs.akamai.com/linode-api/reference/post-linode-instance) for details.
  - For more information, see our guide on [Getting Started with VLANs](https://www.linode.com/docs/products/networking/vlans/get-started/).

- Create an empty Linode.
  - The Linode will remain `offline` and must be manually started.
    - Run [Boot a Linode](https://techdocs.akamai.com/linode-api/reference/post-boot-linode-instance).
  - Disks and Configs must be created manually.
  - This is only recommended for advanced use cases.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes create \
  --label linode123 \
  --root_pass aComplex@Password \
  --booted true \
  --stackscript_id 10079 \
  --stackscript_data '{"gh_username": "linode"}' \
  --region us-east \
  --disk_encryption enabled\
  --placement_group.id 528 \
  --type g6-standard-2 \
  --authorized_keys "ssh-rsa AAAA_valid_public_ssh_key_123456785== user@their-computer" \
  --authorized_users "myUser" \
  --authorized_users "secondaryUser" \
  --metadata.user_data "I2Nsb3VkLWNvbmZpZw==" \
  --firewall_id 9000
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @return ApiPostLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostLinodeInstance(ctx context.Context, apiVersion string) ApiPostLinodeInstanceRequest {
	return ApiPostLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
	}
}

// Execute executes the request
//  @return Linode1
func (a *LinodeInstancesAPIService) PostLinodeInstanceExecute(r ApiPostLinodeInstanceRequest) (*Linode1, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *Linode1
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postLinodeInstanceRequest == nil {
		return localVarReturnValue, nil, reportError("postLinodeInstanceRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostMigrateLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postMigrateLinodeInstanceRequest *PostMigrateLinodeInstanceRequest
}

func (r ApiPostMigrateLinodeInstanceRequest) PostMigrateLinodeInstanceRequest(postMigrateLinodeInstanceRequest PostMigrateLinodeInstanceRequest) ApiPostMigrateLinodeInstanceRequest {
	r.postMigrateLinodeInstanceRequest = &postMigrateLinodeInstanceRequest
	return r
}

func (r ApiPostMigrateLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostMigrateLinodeInstanceExecute(r)
}

/*
PostMigrateLinodeInstance Initiate a DC migration/pending host migration

Initiate a pending host migration that has been scheduled by Linode or initiate a cross data center (DC) migration.  A list of pending migrations, if any, can be accessed from [List notifications](https://techdocs.akamai.com/linode-api/reference/get-notifications). When the migration begins, your Linode will be shutdown if not already off. If the migration initiated the shutdown, it will reboot the Linode when completed.

To initiate a cross DC migration, you must pass a `region` parameter to the request body specifying the target data center region. You can view a list of all available regions and their feature capabilities from [List regions](https://techdocs.akamai.com/linode-api/reference/get-regions). See our [Pricing Page](https://www.linode.com/pricing/) for Region-specific pricing, which applies after migration is complete. If your Linode has a DC migration already queued or you have initiated a previously scheduled migration, you will not be able to initiate a DC migration until it has completed.

`vpc` details

- Cross DC migrations are not allowed for Linodes that have a `vpc` purpose Configuration Profile Interface. Host migrations within the same DC are permitted.
- See the [VPC documentation](https://www.linode.com/docs/products/networking/vpc/#technical-specifications) guide for its specifications and limitations.

`vlan` details

- Only Next Generation Network (NGN) data centers support VLANs. Run the [List regions](https://techdocs.akamai.com/linode-api/reference/get-regions) operation to view the capabilities of data center regions. If a VLAN is attached to your Linode and you attempt to migrate or clone it to a non-NGN data center, the migration or cloning will not initiate. If a Linode cannot be migrated or cloned because of an incompatibility, you will be prompted to select a different data center or contact support.
- Next Generation Network (NGN) data centers do not support IPv6 `/116` pools or IP Failover. If you have these features enabled on your Linode and attempt to migrate to an NGN data center, the migration will not initiate. If a Linode cannot be migrated because of an incompatibility, you will be prompted to select a different data center or contact support.
- See the [VLANs Overview](https://www.linode.com/docs/products/networking/vlans/#technical-specifications) guide to view additional specifications and limitations.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes migrate 123 \
  --region us-central \
  --placement_group.id 528
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to migrate.
 @return ApiPostMigrateLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostMigrateLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostMigrateLinodeInstanceRequest {
	return ApiPostMigrateLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostMigrateLinodeInstanceExecute(r ApiPostMigrateLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostMigrateLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/migrate"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postMigrateLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostMutateLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postMutateLinodeInstanceRequest *PostMutateLinodeInstanceRequest
}

// Whether to automatically resize disks or not.
func (r ApiPostMutateLinodeInstanceRequest) PostMutateLinodeInstanceRequest(postMutateLinodeInstanceRequest PostMutateLinodeInstanceRequest) ApiPostMutateLinodeInstanceRequest {
	r.postMutateLinodeInstanceRequest = &postMutateLinodeInstanceRequest
	return r
}

func (r ApiPostMutateLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostMutateLinodeInstanceExecute(r)
}

/*
PostMutateLinodeInstance Upgrade a Linode

Linodes created with now-deprecated Types are entitled to a free upgrade to the next generation. A mutating Linode will be allocated any new resources the upgraded Type provides, and will be subsequently restarted if it was currently running. If any actions are currently running or queued, those actions must be completed first before you can initiate a mutate.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes upgrade 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to mutate.
 @return ApiPostMutateLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostMutateLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostMutateLinodeInstanceRequest {
	return ApiPostMutateLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostMutateLinodeInstanceExecute(r ApiPostMutateLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostMutateLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/mutate"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postMutateLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostRebootLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postRebootLinodeInstanceRequest *PostRebootLinodeInstanceRequest
}

// Optional reboot parameters.
func (r ApiPostRebootLinodeInstanceRequest) PostRebootLinodeInstanceRequest(postRebootLinodeInstanceRequest PostRebootLinodeInstanceRequest) ApiPostRebootLinodeInstanceRequest {
	r.postRebootLinodeInstanceRequest = &postRebootLinodeInstanceRequest
	return r
}

func (r ApiPostRebootLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostRebootLinodeInstanceExecute(r)
}

/*
PostRebootLinodeInstance Reboot a Linode

Reboots a Linode you have permission to modify. If any actions are currently running or queued, those actions must be completed first before you can initiate a reboot.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes reboot 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the linode to reboot.
 @return ApiPostRebootLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostRebootLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostRebootLinodeInstanceRequest {
	return ApiPostRebootLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostRebootLinodeInstanceExecute(r ApiPostRebootLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostRebootLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/reboot"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postRebootLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostRebuildLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postRebuildLinodeInstanceRequest *PostRebuildLinodeInstanceRequest
}

// The requested state your Linode will be rebuilt into.
func (r ApiPostRebuildLinodeInstanceRequest) PostRebuildLinodeInstanceRequest(postRebuildLinodeInstanceRequest PostRebuildLinodeInstanceRequest) ApiPostRebuildLinodeInstanceRequest {
	r.postRebuildLinodeInstanceRequest = &postRebuildLinodeInstanceRequest
	return r
}

func (r ApiPostRebuildLinodeInstanceRequest) Execute() (*Linode1, *http.Response, error) {
	return r.ApiService.PostRebuildLinodeInstanceExecute(r)
}

/*
PostRebuildLinodeInstance Rebuild a Linode

Rebuilds a Linode you have the `read_write` permission to modify.

A rebuild will first shut down the Linode, delete all disks and configs on the Linode, and then deploy a new `image` to the Linode with the given attributes. Additionally:

  - Requires an `image` be supplied.
  - Requires a `root_pass` be supplied to use for the root User's Account.
  - It is recommended to supply SSH keys for the root User using the `authorized_keys` field.
  - Linodes utilizing Metadata (`"has_user_data": true`) should include `metadata.user_data` in the rebuild request to continue using the service.

During a rebuild, you can `enable` or `disable` local disk encryption. If disk encryption is not included in the request, the previous `disk_encryption` value is used. Disk encryption cannot be disabled if the compute instance is attached to a LKE nodepool.

You also have the option to resize the Linode to a different plan by including the `type` parameter with your request. Note that resizing involves migrating the Linode to a new hardware host, while rebuilding without resizing maintains the same hardware host. Resizing also requires significantly more time for completion of this operation. The following additional conditions apply:

  - The Linode must not have a pending migration.
  - Your Account cannot have an outstanding balance.
  - The Linode must not have more disk allocation than the new Type allows.
    - In that situation, you must first delete or resize the disk to be smaller.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes rebuild 123 \
  --image "linode/debian9" \
  --root_pass aComplex@Password \
  --disk_encryption disabled \
  --authorized_keys "ssh-rsa AAAA_valid_public_ssh_key_123456785== user@their-computer" \
  --authorized_users "myUsername" \
  --authorized_users "secondaryUsername" \
  --booted true \
  --stackscript_id 10079 \
  --stackscript_data '{"gh_username": "linode"}' \
  --type "g6-standard-2" \
  --metadata.userdata "I2Nsb3VkLWNvbmZpZw=="
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to rebuild.
 @return ApiPostRebuildLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostRebuildLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostRebuildLinodeInstanceRequest {
	return ApiPostRebuildLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return Linode1
func (a *LinodeInstancesAPIService) PostRebuildLinodeInstanceExecute(r ApiPostRebuildLinodeInstanceRequest) (*Linode1, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *Linode1
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostRebuildLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/rebuild"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postRebuildLinodeInstanceRequest == nil {
		return localVarReturnValue, nil, reportError("postRebuildLinodeInstanceRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postRebuildLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostRescueLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postRescueLinodeInstanceRequest *PostRescueLinodeInstanceRequest
}

// Optional object of devices to be mounted.
func (r ApiPostRescueLinodeInstanceRequest) PostRescueLinodeInstanceRequest(postRescueLinodeInstanceRequest PostRescueLinodeInstanceRequest) ApiPostRescueLinodeInstanceRequest {
	r.postRescueLinodeInstanceRequest = &postRescueLinodeInstanceRequest
	return r
}

func (r ApiPostRescueLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostRescueLinodeInstanceExecute(r)
}

/*
PostRescueLinodeInstance Boot a Linode into rescue mode

Rescue Mode is a safe environment for performing many system recovery and disk management tasks. Rescue Mode is based on the Finnix recovery distribution, a self-contained and bootable Linux distribution. You can also use Rescue Mode for tasks other than disaster recovery, such as formatting disks to use different filesystems, copying data between disks, and downloading files from a disk via SSH and SFTP.

- Note that `sdh` is reserved and unavailable during rescue.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes rescue 123 \
  --devices.sda.disk_id 124458
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to rescue.
 @return ApiPostRescueLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostRescueLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostRescueLinodeInstanceRequest {
	return ApiPostRescueLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostRescueLinodeInstanceExecute(r ApiPostRescueLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostRescueLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/rescue"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postRescueLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostResetDiskPasswordRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	diskId int32
	postResetDiskPasswordRequest *PostResetDiskPasswordRequest
}

// The new password.
func (r ApiPostResetDiskPasswordRequest) PostResetDiskPasswordRequest(postResetDiskPasswordRequest PostResetDiskPasswordRequest) ApiPostResetDiskPasswordRequest {
	r.postResetDiskPasswordRequest = &postResetDiskPasswordRequest
	return r
}

func (r ApiPostResetDiskPasswordRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostResetDiskPasswordExecute(r)
}

/*
PostResetDiskPassword Reset a disk root password

Resets the password of a Disk you have permission to `read_write`.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disk-reset-password \
  123 25674 \
  --password aComplex@Password
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param diskId ID of the Disk to look up.
 @return ApiPostResetDiskPasswordRequest
*/
func (a *LinodeInstancesAPIService) PostResetDiskPassword(ctx context.Context, apiVersion string, linodeId int32, diskId int32) ApiPostResetDiskPasswordRequest {
	return ApiPostResetDiskPasswordRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		diskId: diskId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostResetDiskPasswordExecute(r ApiPostResetDiskPasswordRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostResetDiskPassword")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks/{diskId}/password"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"diskId"+"}", url.PathEscape(parameterValueToString(r.diskId, "diskId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postResetDiskPasswordRequest == nil {
		return localVarReturnValue, nil, reportError("postResetDiskPasswordRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postResetDiskPasswordRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostResetLinodePasswordRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postResetLinodePasswordRequest *PostResetLinodePasswordRequest
}

// This Linode&#39;s new root password.
func (r ApiPostResetLinodePasswordRequest) PostResetLinodePasswordRequest(postResetLinodePasswordRequest PostResetLinodePasswordRequest) ApiPostResetLinodePasswordRequest {
	r.postResetLinodePasswordRequest = &postResetLinodePasswordRequest
	return r
}

func (r ApiPostResetLinodePasswordRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostResetLinodePasswordExecute(r)
}

/*
PostResetLinodePassword Reset a Linode's root password

Resets the root password for this Linode.

- Your Linode must be [shut down](https://techdocs.akamai.com/linode-api/reference/post-shutdown-linode-instance) for a password reset to complete.
- If your Linode has more than one disk (not counting its swap disk), run the [Reset a disk root password](https://techdocs.akamai.com/linode-api/reference/post-reset-disk-password) operation to update a specific disk's root password.
- A `password_reset` event is generated when a root password reset is successful.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes linode-reset-password 123 a$eCure4assw0rd!43v51
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode for which to reset its root password.
 @return ApiPostResetLinodePasswordRequest
*/
func (a *LinodeInstancesAPIService) PostResetLinodePassword(ctx context.Context, apiVersion string, linodeId int32) ApiPostResetLinodePasswordRequest {
	return ApiPostResetLinodePasswordRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostResetLinodePasswordExecute(r ApiPostResetLinodePasswordRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostResetLinodePassword")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/password"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postResetLinodePasswordRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostResizeDiskRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	diskId int32
	postResizeDiskRequest *PostResizeDiskRequest
}

// The new size of the Disk.
func (r ApiPostResizeDiskRequest) PostResizeDiskRequest(postResizeDiskRequest PostResizeDiskRequest) ApiPostResizeDiskRequest {
	r.postResizeDiskRequest = &postResizeDiskRequest
	return r
}

func (r ApiPostResizeDiskRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostResizeDiskExecute(r)
}

/*
PostResizeDisk Resize a disk

Resizes a Disk you have permission to `read_write`.

The Disk must not be in use. If the Disk is in use, the request will succeed but the resize will ultimately fail. For a request to succeed, the Linode must be shut down prior to resizing the Disk, or the Disk must not be assigned to the Linode's active Configuration Profile.

If you are resizing the Disk to a smaller size, it cannot be made smaller than what is required by the total size of the files current on the Disk.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disk-resize 123 25674 \
  --size 2048
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param diskId ID of the Disk to look up.
 @return ApiPostResizeDiskRequest
*/
func (a *LinodeInstancesAPIService) PostResizeDisk(ctx context.Context, apiVersion string, linodeId int32, diskId int32) ApiPostResizeDiskRequest {
	return ApiPostResizeDiskRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		diskId: diskId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostResizeDiskExecute(r ApiPostResizeDiskRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostResizeDisk")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks/{diskId}/resize"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"diskId"+"}", url.PathEscape(parameterValueToString(r.diskId, "diskId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postResizeDiskRequest == nil {
		return localVarReturnValue, nil, reportError("postResizeDiskRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postResizeDiskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostResizeLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postResizeLinodeInstanceRequest *PostResizeLinodeInstanceRequest
}

// The Type your current Linode will resize to, and whether to attempt to automatically resize the Linode&#39;s disks.
func (r ApiPostResizeLinodeInstanceRequest) PostResizeLinodeInstanceRequest(postResizeLinodeInstanceRequest PostResizeLinodeInstanceRequest) ApiPostResizeLinodeInstanceRequest {
	r.postResizeLinodeInstanceRequest = &postResizeLinodeInstanceRequest
	return r
}

func (r ApiPostResizeLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostResizeLinodeInstanceExecute(r)
}

/*
PostResizeLinodeInstance Resize a Linode

Resizes a Linode you have the `read_write` permission to a different Type. If any actions are currently running or queued, those actions must be completed first before you can initiate a resize. Additionally, the following criteria must be met in order to resize a Linode:

  - The Linode must not have a pending migration.
  - Your Account cannot have an outstanding balance.
  - The Linode must not have more disk allocation than the new Type allows.
    - In that situation, you must first delete or resize the disk to be smaller.

You can also resize a Linode when using the [Rebuild a Linode](https://techdocs.akamai.com/linode-api/reference/post-rebuild-linode-instance) operation.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes resize 123 \
  --type g6-standard-2
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to resize.
 @return ApiPostResizeLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostResizeLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostResizeLinodeInstanceRequest {
	return ApiPostResizeLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostResizeLinodeInstanceExecute(r ApiPostResizeLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostResizeLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/resize"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postResizeLinodeInstanceRequest == nil {
		return localVarReturnValue, nil, reportError("postResizeLinodeInstanceRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postResizeLinodeInstanceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostRestoreBackupRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	backupId int32
	postRestoreBackupRequest *PostRestoreBackupRequest
}

// Parameters to provide when restoring the Backup.
func (r ApiPostRestoreBackupRequest) PostRestoreBackupRequest(postRestoreBackupRequest PostRestoreBackupRequest) ApiPostRestoreBackupRequest {
	r.postRestoreBackupRequest = &postRestoreBackupRequest
	return r
}

func (r ApiPostRestoreBackupRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostRestoreBackupExecute(r)
}

/*
PostRestoreBackup Restore a backup

Restores a Linode's Backup to the specified Linode.

The following conditions apply:

  - Backups may not be restored across Regions.
  - Only successfully completed Backups that are not undergoing maintenance can be restored.
  - The Linode that the Backup is being restored to must not itself be in the process of creating a Backup.

__Note__. When you restore a backup, the restored disk is assigned the same [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier) as the original disk. In most cases, this is acceptable and does not cause issues. However, if you attempt to mount both the original disk and the corresponding restore disk at the same time (by assigning them both to devices in your Configuration Profile's __Block Device Assignment__), you will encounter a UUID "collision".

When this happens, the system selects, and mounts, only one of the disks at random. This is due to both disks sharing the same UUID, and your instance _may fail to boot_ since it will not be clear which disk is root. If your system does boot, you will not see any immediate indication if you are booted into the restored disk or the original disk, and you will be unable to access both disks at the same time.

To avoid this, we recommend only restoring a backup to the same Compute Instance if you do not intend on mounting them at the same time or are comfortable modifying UUIDs. If you need access to files on both the original disk and the restored disk simultaneously (such as needing to copy files between them), we suggest either restoring the backup to a separate Compute Instance or [creating](https://techdocs.akamai.com/linode-api/reference/post-linode-instance) a new Compute Instance with the desired `backup_id`.

To learn more about block device assignments and viewing your disks' UUIDs, see our guide on [Configuration Profiles](https://www.linode.com/docs/products/compute/compute-instances/guides/configuration-profiles/#block-device-assignment).

__Note__. Backups are not encrypted even when they are taken from an encrypted disk. When a backup is restored, and if encryption is enabled, the data stored on the disk is encrypted again.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes backup-restore 123 123456 \
  --linode_id 234 \
  --overwrite true
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode that the Backup belongs to.
 @param backupId The ID of the Backup to restore.
 @return ApiPostRestoreBackupRequest
*/
func (a *LinodeInstancesAPIService) PostRestoreBackup(ctx context.Context, apiVersion string, linodeId int32, backupId int32) ApiPostRestoreBackupRequest {
	return ApiPostRestoreBackupRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		backupId: backupId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostRestoreBackupExecute(r ApiPostRestoreBackupRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostRestoreBackup")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/backups/{backupId}/restore"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"backupId"+"}", url.PathEscape(parameterValueToString(r.backupId, "backupId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postRestoreBackupRequest == nil {
		return localVarReturnValue, nil, reportError("postRestoreBackupRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postRestoreBackupRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostShutdownLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
}

func (r ApiPostShutdownLinodeInstanceRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.PostShutdownLinodeInstanceExecute(r)
}

/*
PostShutdownLinodeInstance Shut down a Linode

Shuts down a Linode you have permission to modify. If any actions are currently running or queued, those actions must be completed first before you can initiate a shutdown.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes shutdown 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to shutdown.
 @return ApiPostShutdownLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PostShutdownLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPostShutdownLinodeInstanceRequest {
	return ApiPostShutdownLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return map[string]interface{}
func (a *LinodeInstancesAPIService) PostShutdownLinodeInstanceExecute(r ApiPostShutdownLinodeInstanceRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  map[string]interface{}
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostShutdownLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/shutdown"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPostSnapshotRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	postSnapshotRequest *PostSnapshotRequest
}

func (r ApiPostSnapshotRequest) PostSnapshotRequest(postSnapshotRequest PostSnapshotRequest) ApiPostSnapshotRequest {
	r.postSnapshotRequest = &postSnapshotRequest
	return r
}

func (r ApiPostSnapshotRequest) Execute() (*GetBackups200ResponseSnapshotCurrent, *http.Response, error) {
	return r.ApiService.PostSnapshotExecute(r)
}

/*
PostSnapshot Create a snapshot

Creates a snapshot backup of a Linode.

__Note__. Backups are not encrypted even when they are taken from an encrypted disk. When a backup is restored, and if encryption is enabled, the data stored on the disk is encrypted again.

__Important__. If you already have a snapshot of this Linode, this is a destructive action. The previous snapshot will be deleted.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes snapshot 123
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode the backups belong to.
 @return ApiPostSnapshotRequest
*/
func (a *LinodeInstancesAPIService) PostSnapshot(ctx context.Context, apiVersion string, linodeId int32) ApiPostSnapshotRequest {
	return ApiPostSnapshotRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return GetBackups200ResponseSnapshotCurrent
func (a *LinodeInstancesAPIService) PostSnapshotExecute(r ApiPostSnapshotRequest) (*GetBackups200ResponseSnapshotCurrent, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetBackups200ResponseSnapshotCurrent
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PostSnapshot")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/backups"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.postSnapshotRequest == nil {
		return localVarReturnValue, nil, reportError("postSnapshotRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.postSnapshotRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPutDiskRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	diskId int32
	putDiskRequest *PutDiskRequest
}

// Updates the parameters of a single Disk.
func (r ApiPutDiskRequest) PutDiskRequest(putDiskRequest PutDiskRequest) ApiPutDiskRequest {
	r.putDiskRequest = &putDiskRequest
	return r
}

func (r ApiPutDiskRequest) Execute() (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	return r.ApiService.PutDiskExecute(r)
}

/*
PutDisk Update a disk

Updates a Disk that you have permission to `read_write`.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes disk-update 123 25674 \
  --label "Debian 9 Disk"
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @param diskId ID of the Disk to look up.
 @return ApiPutDiskRequest
*/
func (a *LinodeInstancesAPIService) PutDisk(ctx context.Context, apiVersion string, linodeId int32, diskId int32) ApiPutDiskRequest {
	return ApiPutDiskRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		diskId: diskId,
	}
}

// Execute executes the request
//  @return GetLinodeDisks200ResponseDataInner
func (a *LinodeInstancesAPIService) PutDiskExecute(r ApiPutDiskRequest) (*GetLinodeDisks200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeDisks200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PutDisk")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/disks/{diskId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"diskId"+"}", url.PathEscape(parameterValueToString(r.diskId, "diskId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.putDiskRequest == nil {
		return localVarReturnValue, nil, reportError("putDiskRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.putDiskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPutLinodeConfigRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
	getLinodeConfigs200ResponseDataInner *GetLinodeConfigs200ResponseDataInner
}

// The Configuration profile parameters to modify.
func (r ApiPutLinodeConfigRequest) GetLinodeConfigs200ResponseDataInner(getLinodeConfigs200ResponseDataInner GetLinodeConfigs200ResponseDataInner) ApiPutLinodeConfigRequest {
	r.getLinodeConfigs200ResponseDataInner = &getLinodeConfigs200ResponseDataInner
	return r
}

func (r ApiPutLinodeConfigRequest) Execute() (*GetLinodeConfigs200ResponseDataInner, *http.Response, error) {
	return r.ApiService.PutLinodeConfigExecute(r)
}

/*
PutLinodeConfig Update a config profile

Updates a Configuration profile.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-update 123 23456 \
  --kernel "linode/latest-64bit" \
  --comments "This is my main Config" \
  --memory_limit 2048 \
  --run_level default \
  --virt_mode paravirt \
  --helpers.updatedb_disabled true \
  --helpers.distro true \
  --helpers.modules_dep true \
  --helpers.network true \
  --helpers.devtmpfs_automount false \
  --label "My Config" \
  --devices.sda.disk_id 123456 \
  --devices.sdb.disk_id 123457
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @return ApiPutLinodeConfigRequest
*/
func (a *LinodeInstancesAPIService) PutLinodeConfig(ctx context.Context, apiVersion string, linodeId int32, configId int32) ApiPutLinodeConfigRequest {
	return ApiPutLinodeConfigRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
	}
}

// Execute executes the request
//  @return GetLinodeConfigs200ResponseDataInner
func (a *LinodeInstancesAPIService) PutLinodeConfigExecute(r ApiPutLinodeConfigRequest) (*GetLinodeConfigs200ResponseDataInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeConfigs200ResponseDataInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PutLinodeConfig")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.getLinodeConfigs200ResponseDataInner == nil {
		return localVarReturnValue, nil, reportError("getLinodeConfigs200ResponseDataInner is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.getLinodeConfigs200ResponseDataInner
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPutLinodeConfigInterfaceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	configId int32
	interfaceId int32
	putLinodeConfigInterfaceRequest *PutLinodeConfigInterfaceRequest
}

// The updated Interface.
func (r ApiPutLinodeConfigInterfaceRequest) PutLinodeConfigInterfaceRequest(putLinodeConfigInterfaceRequest PutLinodeConfigInterfaceRequest) ApiPutLinodeConfigInterfaceRequest {
	r.putLinodeConfigInterfaceRequest = &putLinodeConfigInterfaceRequest
	return r
}

func (r ApiPutLinodeConfigInterfaceRequest) Execute() (*PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	return r.ApiService.PutLinodeConfigInterfaceExecute(r)
}

/*
PutLinodeConfigInterface Update a configuration profile interface

Updates a `vpc` or `public` purpose Interface for this Configuration Profile.

- The User accessing this operation must have `read_write` grants to the Linode.
- A successful request triggers a `linode_config_update` event.
- The Interface `purpose` cannot be updated with this operation.
- VPC Subnets cannot be updated on an Interface. A new `vpc` purpose Interface must be created to assign a different Subnet to a Configuration Profile.
- Only `primary` can be updated for `public` purpose Interfaces.
- This operation not currently allowed for `vlan` purpose Interfaces.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes config-interface-update $linodeId $configId $interfaceId \
  --primary true \
  --ipv4.vpc "10.0.1.2" \
  --ipv4.nat_1_1 "203.0.113.2"
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The `id` of the Linode.
 @param configId The `id` of the Configuration Profile.
 @param interfaceId The `id` of the Linode Configuration Profile Interface.
 @return ApiPutLinodeConfigInterfaceRequest
*/
func (a *LinodeInstancesAPIService) PutLinodeConfigInterface(ctx context.Context, apiVersion string, linodeId int32, configId int32, interfaceId int32) ApiPutLinodeConfigInterfaceRequest {
	return ApiPutLinodeConfigInterfaceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		configId: configId,
		interfaceId: interfaceId,
	}
}

// Execute executes the request
//  @return PostLinodeInstanceRequestAllOfInterfacesInner
func (a *LinodeInstancesAPIService) PutLinodeConfigInterfaceExecute(r ApiPutLinodeConfigInterfaceRequest) (*PostLinodeInstanceRequestAllOfInterfacesInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *PostLinodeInstanceRequestAllOfInterfacesInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PutLinodeConfigInterface")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/configs/{configId}/interfaces/{interfaceId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"configId"+"}", url.PathEscape(parameterValueToString(r.configId, "configId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"interfaceId"+"}", url.PathEscape(parameterValueToString(r.interfaceId, "interfaceId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.putLinodeConfigInterfaceRequest == nil {
		return localVarReturnValue, nil, reportError("putLinodeConfigInterfaceRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.putLinodeConfigInterfaceRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPutLinodeInstanceRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	linode1 *Linode1
}

// Any field that is not marked as &#x60;readOnly&#x60; may be updated. Fields that are marked &#x60;readOnly&#x60; will be ignored. If any updated field fails to pass validation, the Linode will not be updated.
func (r ApiPutLinodeInstanceRequest) Linode1(linode1 Linode1) ApiPutLinodeInstanceRequest {
	r.linode1 = &linode1
	return r
}

func (r ApiPutLinodeInstanceRequest) Execute() (*Linode1, *http.Response, error) {
	return r.ApiService.PutLinodeInstanceExecute(r)
}

/*
PutLinodeInstance Update a Linode

Updates a Linode that you have permission to `read_write`.

__Important__. You must be an unrestricted User in order to add or modify tags on Linodes.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes update 7833080 \
  --label linode123 \
  --backups.schedule.day "Saturday" \
  --backups.schedule.window "W22" \
  --alerts.cpu 180 \
  --alerts.network_in 10 \
  --alerts.network_out 10 \
  --alerts.transfer_quota 80 \
  --alerts.io 10000
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId ID of the Linode to look up.
 @return ApiPutLinodeInstanceRequest
*/
func (a *LinodeInstancesAPIService) PutLinodeInstance(ctx context.Context, apiVersion string, linodeId int32) ApiPutLinodeInstanceRequest {
	return ApiPutLinodeInstanceRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
	}
}

// Execute executes the request
//  @return Linode1
func (a *LinodeInstancesAPIService) PutLinodeInstanceExecute(r ApiPutLinodeInstanceRequest) (*Linode1, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *Linode1
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PutLinodeInstance")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.linode1 == nil {
		return localVarReturnValue, nil, reportError("linode1 is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.linode1
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiPutLinodeIpRequest struct {
	ctx context.Context
	ApiService *LinodeInstancesAPIService
	apiVersion string
	linodeId int32
	address string
	putLinodeIpRequest *PutLinodeIpRequest
}

// The information to update for the IP address.
func (r ApiPutLinodeIpRequest) PutLinodeIpRequest(putLinodeIpRequest PutLinodeIpRequest) ApiPutLinodeIpRequest {
	r.putLinodeIpRequest = &putLinodeIpRequest
	return r
}

func (r ApiPutLinodeIpRequest) Execute() (*GetLinodeIps200ResponseIpv4PublicInner, *http.Response, error) {
	return r.ApiService.PutLinodeIpExecute(r)
}

/*
PutLinodeIp Update an IP address's RDNS for a Linode

Updates the reverse DNS (RDNS) for a Linode's IP Address. This may be done for both IPv4 and IPv6 addresses.

Setting the RDNS to `null` for a public IPv4 address, resets it to the default `ip.linodeusercontent.com` RDNS value.


<<LB>>

---


- __CLI__.

    ```
    linode-cli linodes ip-update 123 \
  203.0.113.1 \
  --rdns test.example.org
    ```

    [Learn more...](https://www.linode.com/docs/products/tools/cli/get-started/)

- __OAuth scopes__.

    ```
    linodes:read_write
    ```

    [Learn more...](https://techdocs.akamai.com/linode-api/reference/get-started#oauth)

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param apiVersion __Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.
 @param linodeId The ID of the Linode.
 @param address The IP address.
 @return ApiPutLinodeIpRequest
*/
func (a *LinodeInstancesAPIService) PutLinodeIp(ctx context.Context, apiVersion string, linodeId int32, address string) ApiPutLinodeIpRequest {
	return ApiPutLinodeIpRequest{
		ApiService: a,
		ctx: ctx,
		apiVersion: apiVersion,
		linodeId: linodeId,
		address: address,
	}
}

// Execute executes the request
//  @return GetLinodeIps200ResponseIpv4PublicInner
func (a *LinodeInstancesAPIService) PutLinodeIpExecute(r ApiPutLinodeIpRequest) (*GetLinodeIps200ResponseIpv4PublicInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetLinodeIps200ResponseIpv4PublicInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinodeInstancesAPIService.PutLinodeIp")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/{apiVersion}/linode/instances/{linodeId}/ips/{address}"
	localVarPath = strings.Replace(localVarPath, "{"+"apiVersion"+"}", url.PathEscape(parameterValueToString(r.apiVersion, "apiVersion")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"linodeId"+"}", url.PathEscape(parameterValueToString(r.linodeId, "linodeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"address"+"}", url.PathEscape(parameterValueToString(r.address, "address")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.putLinodeIpRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
			var v GetAccountDefaultResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}