Skip to content

Instantly share code, notes, and snippets.

@displague

displague/README.md Secret

Last active March 27, 2018 04:21
Show Gist options
  • Save displague/31700ba03009d1a183297949c54e7471 to your computer and use it in GitHub Desktop.
Save displague/31700ba03009d1a183297949c54e7471 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
README.md

gnostic -> go client

https://github.com/googleapis/gnostic -- generate-gnostic --v3 don't know?

go install github.com/googleapis/gnostic
go install github.com/googleapis/gnostic/plugins/gnostic-go-generator/
gnostic linodeapi3.yaml --go-generator-out=linodeapi3

alias retab='vim -s <(echo -e "gg=G\n:retab\nZZ")'

With every attempted fix, I rerun:

( cd ../; gnostic linode/linodeapi3.yaml --go-generator-out=linode 2> linode/output.txt ; go build 2>> linode/output.txt ); sed -i ''  's/&interface{}{}/struct{}{}/g' client.go; for a in *go; do retab $a; done; git diff -w

2018/03/24 07:47:49 unimplemented: type:"array" items:<schema:<type:"array" items:<schema:<example:<yaml:"- 1521483600000\n- 0.42\n" > type:"number" > > > > description:"Percentage of CPU used.\n"
2018/03/24 07:47:49 unimplemented: specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/24 07:47:49 unimplemented: read_only:true description:"This is the location where the Linode was deployed. This cannot be changed without opening a support ticket.\n" specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/24 07:47:49 unimplemented: read_only:true description:"This will show one of the following conditions, which Linode Distribution image this Linode was created with, which Linode Distribution was booted if there are multiple disks attached to the Linode Config, or `null` if neither of those conditions were met.\n" specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/24 07:47:49 unimplemented: read_only:true description:"This is the Linode service plan type that this Linode was deployed with.\n\nTo change a Linode's type, use `POST /linode/instances/{linodeId}/resize`.\n"
2018/03/24 07:47:49 unimplemented: specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/24 07:47:49 unimplemented: read_only:true type:"array" items:<schema:<example:<yaml:"654\n" > type:"integer" format:"int32" > > description:"An array of Managed Service ids that were affected by this issue.\n"
2018/03/24 07:47:49 unimplemented: type:"array" items:<schema:<example:<yaml:"9991\n" > type:"integer" format:"int32" > > description:"An array of ManagedCredential ids that should be used when attempting to resolve issues with this service.\n"
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Event" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Invoice" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/InvoiceItem" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Notification" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/OAuthClient" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"label" required:"redirect_uri" all_of:<reference:<_ref:"#/components/schemas/OAuthClient" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"public" value:<schema:<example:<yaml:"false\n" > type:"boolean" description:"Whether to create a public of private client." > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Payment" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/User" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"username" required:"email" required:"password" all_of:<reference:<_ref:"#/components/schemas/User" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"email" value:<schema:<example:<yaml:"example_user@linode.com\n" > type:"string" description:"The new user's email address.\n" format:"email" > > > additional_properties:<name:"password" value:<schema:<example:<yaml:"hunter7\n" > type:"string" description:"The password this user will user to log in.\n" > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Domain" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Linode" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Volume" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/LinodeConfig" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Kernel" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/StackScript" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/LinodeType" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/ManagedContact" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/ManagedCredential" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"label" all_of:<reference:<_ref:"#/components/schemas/ManagedCredential" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"username" value:<schema:<example:<yaml:"johndoe\n" > max_length:5000 type:"string" description:"The username to use when accessing the Managed Service.\n" > > > additional_properties:<name:"password" value:<schema:<example:<yaml:"hunter7\n" > max_length:5000 type:"string" description:"The password to use when accessing the Managed Service.\n" > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/ManagedIssue" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/ManagedLinodeSettings" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/ManagedService" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"label" all_of:<reference:<_ref:"#/components/schemas/ManagedService" > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/IPAddress" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"type" required:"linode_id" properties:<additional_properties:<name:"type" value:<schema:<example:<yaml:"ipv4\n" > enum:<yaml:"ipv4\n" > type:"string" description:"The type of address you are requesting.  Right now, only public ipv4 addresses may be allocated through this endpoint.\n" > > > additional_properties:<name:"linode_id" value:<schema:<example:<yaml:"123\n" > type:"integer" description:"The ID of a Linode you you have access to that this address will be allocated to.\n" format:"int32" > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/LongviewClient" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/LongviewSubscription" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"region" required:"assignments" properties:<additional_properties:<name:"region" value:<schema:<example:<yaml:"us-east\n" > type:"string" description:"The ID of the region in which these assignments are to take place.  All IPs and Linodes must exist in this region.\n" > > > additional_properties:<name:"assignments" value:<schema:<type:"array" items:<schema:<type:"object" properties:<additional_properties:<name:"address" value:<schema:<example:<yaml:"12.34.56.789\n" > type:"string" description:"Ths IP Address for this assignment.  Must be a v4 address you can access in the region specified.  May be a public or private address.\n" format:"ip" > > > additional_properties:<name:"linode_id" value:<schema:<example:<yaml:"123\n" > type:"integer" description:"The ID of the Linode to assign this address to.  The IP's previous Linode will lose this address, and must end up with at least one public address and no more than one private address once all assignments have been made.\n" format:"int32" > > > > > > description:"The list of assignments to make.  You must have read_write access to all IPs being assigned and all Linodes being assigned to in order for the assignments to succeed.\n" > > > >
2018/03/24 07:47:49 unimplemented: required:"linode_id" required:"ips" properties:<additional_properties:<name:"linode_id" value:<schema:<example:<yaml:"123\n" > type:"integer" description:"The ID of the Linode that the addresses will be shared with.\n" format:"int32" > > > additional_properties:<name:"ips" value:<schema:<type:"array" items:<schema:<example:<yaml:"12.34.56.789\n" > type:"string" format:"ip" > > description:"A list of IPs that will be shared with this Linode.  When this is finished, the given Linode will be able to bring up these addresses in addition to the Linodes that these addresses belong to.  You must have access to all of these addresses and they must be in the same region as the Linode.\n" > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/NodeBalancer" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"region" properties:<additional_properties:<name:"region" value:<schema:<example:<yaml:"us-east\n" > type:"string" description:"The ID of the region to create this NodeBalancer in.\n" > > > additional_properties:<name:"label" value:<reference:<_ref:"#/components/schemas/NodeBalancer/properties/label" > > > additional_properties:<name:"client_conn_throttle" value:<reference:<_ref:"#/components/schemas/NodeBalancer/properties/client_conn_throttle" > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/NodeBalancerConfig" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/NodeBalancerNode" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/NodeBalancerNode" > > all_of:<schema:<required:"label" required:"address" > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Region" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/Volume" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/Volume" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"region" value:<reference:<_ref:"#/components/schemas/Region/properties/id" > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/Volume" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"region" value:<reference:<_ref:"#/components/schemas/Region/properties/id" > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/DomainRecord" > > > > > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/AuthorizedApp" > > > > > > > >
2018/03/24 07:47:49 unimplemented: properties:<additional_properties:<name:"secret" value:<schema:<example:<yaml:"5FXX6KLACOC33GTC\n" > type:"string" description:"Your two-factor secret.  This is used to generate time-based two factor codes required for login. Doing this will be required to confirm TFA an actually enable it.\n" > > > additional_properties:<name:"expiry" value:<schema:<example:<yaml:"2018-03-01T00:01:01\n" > type:"string" description:"When this Two Factor secret expires.\n" format:"date-time" > > > >
2018/03/24 07:47:49 unimplemented: properties:<additional_properties:<name:"tfa_code" value:<schema:<example:<yaml:"\"213456\"\n" > type:"string" description:"The Two Factor code you generated with your Two Factor secret. These codes are time-based, so be sure it is current.\n" > > > >
2018/03/24 07:47:49 unimplemented: properties:<additional_properties:<name:"scratch" value:<schema:<example:<yaml:"sample two factor scratch\n" > type:"string" description:"A one-use code that can be used in place of your Two Factor code, in case you are unable to generate one.  Keep this in a safe place to avoid being locked out of your account.\n" > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/PersonalAccessToken" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"label" properties:<additional_properties:<name:"scopes" value:<schema:<example:<yaml:"'*'\n" > type:"string" description:"The scopes to create the token with.  These cannot be changed after creation, and may not exceed the scopes of the acting token. If omitted, the new token will have the same scopes as the acting token.\n" format:"oauth-scope" > > > additional_properties:<name:"expiry" value:<schema:<type:"string" description:"When this token should be valid until.  If omitted, the new token will be valid until it is manually revoked.\n" format:"date-time" > > > additional_properties:<name:"label" value:<reference:<_ref:"#/components/schemas/PersonalAccessToken/properties/label" > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/SupportTicket" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"file" properties:<additional_properties:<name:"file" value:<schema:<example:<yaml:"/Users/LinodeGuy/pictures/screen_shot.jpg\n" > type:"string" description:"The local, absolute path to the file you want to attach to your Support Ticket.\n" > > > >
2018/03/24 07:47:49 unimplemented: all_of:<reference:<_ref:"#/components/schemas/PaginationEnvelope" > > all_of:<schema:<type:"object" properties:<additional_properties:<name:"data" value:<schema:<type:"array" items:<reference:<_ref:"#/components/schemas/SupportTicketReply" > > > > > > > >
2018/03/24 07:47:49 unimplemented: required:"description" properties:<additional_properties:<name:"description" value:<schema:<example:<yaml:"|\n  Thank you for your help. I was able to figure out what the problem was and I successfully reset my password. You guys are the best!\n" > max_length:65535 min_length:1 type:"string" description:"The content of your reply.\n" > > > >
2018/03/24 07:47:49 Syntax errors in generated code:
client.go:110:14: expected expression
client.go:140:27: expected ';', found ':'
client.go:202:14: expected expression
client.go:236:14: expected expression
client.go:266:27: expected ';', found ':'
client.go:324:27: expected ';', found ':'
client.go:355:27: expected ';', found ':'
client.go:385:27: expected ';', found ':'
client.go:397:14: expected ')', found ':'
client.go:397:562: unknown escape sequence
client.go:404:169: expected 'IDENT', found ':'
2018/03/24 07:47:49 Syntax errors in generated code:
server.go:318:47: missing ',' in argument list
server.go:318:263: unknown escape sequence
server.go:319:1: missing ',' in argument list
server.go:320:38: missing ',' before newline in composite literal
server.go:321:37: missing ',' before newline in composite literal
server.go:322:2: expected operand, found 'return'
server.go:329:1: missing ',' in composite literal
server.go:330:1: expected operand, found 'if'
server.go:332:11: missing ',' in composite literal
server.go:333:31: missing ',' before newline in composite literal
server.go:334:3: expected operand, found 'return'
2018/03/24 07:47:50 Syntax errors in generated code:
types.go:37:18: expected ';', found '{'
types.go:40:1: expected '}', found 'type'
types.go:121:18: expected ';', found ':'
types.go:121:107: unknown escape sequence
types.go:121:115: unknown escape sequence
types.go:121:179: unknown escape sequence
types.go:128:1: expected '}', found 'type'
types.go:283:17: expected ';', found '{'
types.go:289:1: expected '}', found 'type'
types.go:304:20: expected ';', found ':'
types.go:304:92: unknown escape sequence
types.go:305:160: unknown escape sequence
types.go:305:233: unknown escape sequence
types.go:306:307: unknown escape sequence
types.go:306:380: unknown escape sequence
types.go:307:122: unknown escape sequence
types.go:307:124: unknown escape sequence
types.go:307:200: unknown escape sequence
types.go:308:92: unknown escape sequence
Raw
client.go
// GENERATED FILE: DO NOT EDIT!
package linode
// Client represents an API client.
type Client struct {
service string
APIKey string
client *http.Client
}
// NewClient creates an API client.
func NewClient(service string, c *http.Client) *Client {
client := &Client{}
client.service = service
if c != nil {
client.client = c
} else {
client.client = http.DefaultClient
}
return client
}
// This endpoint returns the contact and billing information related to your Account.
//
func (client *Client) GetAccount() (
response *GetAccountResponses,
err error,
) {
path := client.service + "/account"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetAccountResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Account{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to update contact and billing information related to your Account.
//
func (client *Client) UpdateAccount(
account Account,
) (
response *UpdateAccountResponses,
err error,
) {
path := client.service + "/account"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateAccountResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Account{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to add/edit credit card information to your Account.
// Only one credit card can be associated with your Account, so using this endpoint will overwrite your card information with the new credit card.
//
func (client *Client) CreateCreditCard(
creditcard CreditCard,
) (
response *CreateCreditCardResponses,
err error,
) {
path := client.service + "/account/credit-card"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(creditcard)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateCreditCardResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a collection of Event objects representing actions taken on your Account. The events returned depends on your grants.
//
func (client *Client) GetEvents() (
response *GetEventsResponses,
err error,
) {
path := client.service + "/account/events"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetEventsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single Event object.
func (client *Client) GetEvent() (
response *GetEventResponses,
err error,
) {
path := client.service + "/account/events/{eventId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetEventResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Event{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Marks Event as read.
func (client *Client) EventRead() (
response *EventReadResponses,
err error,
) {
path := client.service + "/account/events/{eventId}/read"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &EventReadResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Marks all Events up to and including this Event by ID as seen.
//
func (client *Client) EventSeen() (
response *EventSeenResponses,
err error,
) {
path := client.service + "/account/events/{eventId}/seen"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &EventSeenResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a paginated list of invoices against your Account.
//
func (client *Client) GetInvoices() (
response *GetInvoicesResponses,
err error,
) {
path := client.service + "/account/invoices"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetInvoicesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single Invoice object.
func (client *Client) GetInvoice() (
response *GetInvoiceResponses,
err error,
) {
path := client.service + "/account/invoices/{invoiceId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetInvoiceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Invoice{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Invoice items.
func (client *Client) GetInvoiceItems() (
response *GetInvoiceItemsResponses,
err error,
) {
path := client.service + "/account/invoices/{invoiceId}/items"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetInvoiceItemsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a collection of Notification objects representing important, often time-sensitive items related to your account.
// You cannot interact directly with Notifications, and it will disappear when the circumstances causing the Notification have been resolved. For example, if you have an important ticket open, you must respond to the ticket to dismiss the Notification.
//
func (client *Client) GetNotifications() (
response *GetNotificationsResponses,
err error,
) {
path := client.service + "/account/notifications"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetNotificationsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of OAuth Clients registered to your account. OAuth Clients allow users to log into applications you write or host using their Linode account, and may allow them to grant some level of access to their Linodes or other entities to your application.
//
func (client *Client) GetClients() (
response *GetClientsResponses,
err error,
) {
path := client.service + "/account/oauth-clients"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetClientsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Create a new OAuth Client, which can be used to allow users to login to your own applications using their Linode account, and optionally grant your application some amount of access to their Linodes or other entities.
//
func (client *Client) CreateClient(
object interface{},
) (
response *CreateClientResponses,
err error,
) {
path := client.service + "/account/oauth-clients"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &OAuthClient{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a single OAuth client.
//
func (client *Client) GetClient() (
response *GetClientResponses,
err error,
) {
path := client.service + "/account/oauth-clients/{clientId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &OAuthClient{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update information about an OAuth Client on your account. This can be especially useful to update the redirect_uri of your client in the event that the callback url changed in your application.
//
func (client *Client) UpdateClient(
oauthclient OAuthClient,
) (
response *UpdateClientResponses,
err error,
) {
path := client.service + "/account/oauth-clients/{clientId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &OAuthClient{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes an OAuth Client registered with Linode. The Client ID and Client Secret will no longer be accepted by https://login.linode.com, and all tokens issued to this client will be invalidated (meaning that if your application was using a token, it will no longer work).
//
func (client *Client) DeleteClient() (
response *DeleteClientResponses,
err error,
) {
path := client.service + "/account/oauth-clients/{clientId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns the thumbnail for this OAuth Client. This is a publicly-viewable endpoint, and can be accessed without authentication.
//
func (client *Client) GetClientThumbnail() (
response *GetClientThumbnailResponses,
err error,
) {
path := client.service + "/account/oauth-clients/{clientId}/thumbnail"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetClientThumbnailResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &string{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Upload a thumbnail for a client you own. You must upload an image file that will be returned when the thumbnail is retrieved. This image will be publicly-viewable.
//
func (client *Client) SetClientThumbnail(
string string,
) (
response *SetClientThumbnailResponses,
err error,
) {
path := client.service + "/account/oauth-clients/{clientId}/thumbnail"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &SetClientThumbnailResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Resets the OAuth Client Secret for a client you own, and returns the OAuth Client with the plaintext secret. This secret is not supposed to be publicly known or disclosed anywhere. This can be used to generate a new secret in case the one you have has been leaked, or to get a new secret if you lost the original. The old secret is expired immediately, and logins to your client with the old secret will fail.
//
func (client *Client) ResetClientSecret() (
response *ResetClientSecretResponses,
err error,
) {
path := client.service + "/account/oauth-clients/{clientId}/reset-secret"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ResetClientSecretResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &OAuthClient{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a paginated list of Payments made on this Account.
//
func (client *Client) GetPayments() (
response *GetPaymentsResponses,
err error,
) {
path := client.service + "/account/payments"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetPaymentsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to make a payment to your Account via credit card. This will charge your credit card the requested amount.
//
func (client *Client) CreatePayment(
paymentrequest PaymentRequest,
) (
response *CreatePaymentResponses,
err error,
) {
path := client.service + "/account/payments"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(paymentrequest)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreatePaymentResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Payment{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a specific Payment.
//
func (client *Client) GetPayment() (
response *GetPaymentResponses,
err error,
) {
path := client.service + "/account/payments/{paymentId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetPaymentResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Payment{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This begins the process of submitting a payment via PayPal. After calling
// this endpoint, you must take the resulting `payment_id` along with
// the `payer_id` from your PayPal account, and POST to
// `/account/payments/paypal-execute` to complete the payment.
//
func (client *Client) CreatePayPalPayment(
paypal PayPal,
) (
response *CreatePayPalPaymentResponses,
err error,
) {
path := client.service + "/account/payments/paypal"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(paypal)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreatePayPalPaymentResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &PayPalExecute{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Given a PaymentID and PayerID - as generated by PayPal during the transaction authorization process - this endpoint executes the payment to capture the funds and credit your Linode account.
//
func (client *Client) ExecutePayPalPayment(
paypalexecute PayPalExecute,
) (
response *ExecutePayPalPaymentResponses,
err error,
) {
path := client.service + "/account/payment/paypal/execute"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(paypalexecute)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ExecutePayPalPaymentResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns information related to your Account settings: Managed service subscription, Longview subscription, and network helper.
//
func (client *Client) GetAccountSettings() (
response *GetAccountSettingsResponses,
err error,
) {
path := client.service + "/account/settings"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetAccountSettingsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &AccountSettings{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to update your Account settings.
//
func (client *Client) UpdateAccountSettings(
accountsettings AccountSettings,
) (
response *UpdateAccountSettingsResponses,
err error,
) {
path := client.service + "/account/settings"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateAccountSettingsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &AccountSettings{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Users on your account. Users may access all or part of your account based on their restricted status and grants. An unrestricted user may access everything on the account, whereas restricted user may only access entities or perform actions they've been given specific grants to.
//
func (client *Client) GetUsers() (
response *GetUsersResponses,
err error,
) {
path := client.service + "/account/users"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetUsersResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new User on your account. Once created, the user will be able to log in and access portions of your account. Access is determined by whether or not they are restricted, and what grants they have been given.
//
func (client *Client) CreateUser(
object interface{},
) (
response *CreateUserResponses,
err error,
) {
path := client.service + "/account/users"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateUserResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &User{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a single user on your account.
//
func (client *Client) GetUser() (
response *GetUserResponses,
err error,
) {
path := client.service + "/account/users/{username}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetUserResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &User{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update information about a user on your account. This can be used to change the restricted status of a user. When making a user restricted, no grants will be configured by default and you must then set up grants in order for the user to access anything on the account.
//
func (client *Client) UpdateUser(
user User,
) (
response *UpdateUserResponses,
err error,
) {
path := client.service + "/account/users/{username}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateUserResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &User{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a user. The deleted user will be immediately logged out and may no longer log in or perform any actions. All grants that user had will be lost.
//
func (client *Client) DeleteUser() (
response *DeleteUserResponses,
err error,
) {
path := client.service + "/account/users/{username}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteUserResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns the full grants structure for this user. This includes all entities on the account alongside what level of access this user has to each of them. Individual users may view their own grants at the `/profile/grants` endpoint, but will not see entities that they have no access to.
//
func (client *Client) GetUserGrants() (
response *GetUserGrantsResponses,
err error,
) {
path := client.service + "/account/users/{username}/grants"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetUserGrantsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &GrantsResponse{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update the grants a user has. This can be used to give a user access to new entities or actions, or take access away. You do not need to include the grant for every entity on the account in this request; any that are not included will remain unchanged.
//
func (client *Client) UpdateUserGrants(
grantsresponse GrantsResponse,
) (
response *UpdateUserGrantsResponses,
err error,
) {
path := client.service + "/account/users/{username}/grants"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateUserGrantsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &GrantsResponse{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a Transfer object.
//
func (client *Client) GetTransfer() (
response *GetTransferResponses,
err error,
) {
path := client.service + "/account/transfer"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetTransferResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Transfer{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This is a collection of domains that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for these to work you must own the domains and point your registrar at Linode's nameservers.
//
func (client *Client) GetDomains() (
response *GetDomainsResponses,
err error,
) {
path := client.service + "/domains"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetDomainsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Adds a new domain to Linode's DNS Manager. Linode is not a registrar, and you must own the domain before adding it here. Be sure to point your registrar to Linode's nameservers so that the records hosted here are used.
//
func (client *Client) CreateDomain(
domain Domain,
) (
response *CreateDomainResponses,
err error,
) {
path := client.service + "/domains"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(domain)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateDomainResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Domain{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This is a single domain that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for this domain record to work you must own the domain and point your registrar at Linode's nameservers.
//
func (client *Client) GetDomain() (
response *GetDomainResponses,
err error,
) {
path := client.service + "/domains/{domainId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetDomainResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Domain{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update information about a domain in Linode's DNS Manager.
//
func (client *Client) UpdateDomain(
domain Domain,
) (
response *UpdateDomainResponses,
err error,
) {
path := client.service + "/domains/{domainId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateDomainResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Domain{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a domain from Linode's DNS Manager. The domain will be removed from Linode's nameservers shortly after this operation completes. This also deletes all associated Domain Records.
//
func (client *Client) DeleteDomain() (
response *DeleteDomainResponses,
err error,
) {
path := client.service + "/domains/{domainId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteDomainResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Images. This list includes public Images and your private Images. You can call this enpoint without authentication to get all of the public Images.
//
func (client *Client) GetImages() (
response *GetImagesResponses,
err error,
) {
path := client.service + "/images"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetImagesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new private gold-master Image from a Linode Disk. There is no additional charge to store Images for Linode users, with a limit of 2GB per Image and 3 Images per account.
//
func (client *Client) CreateImage(
object interface{},
) (
response *CreateImageResponses,
err error,
) {
path := client.service + "/images"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateImageResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ImagePrivate{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Get information about a single image.
//
func (client *Client) GetImage() (
response *GetImageResponses,
err error,
) {
path := client.service + "/images/{imageId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetImageResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ImagePrivate{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This allows you to update an private Image that you have permission to `read_write`.
//
func (client *Client) UpdateImage(
imageprivate ImagePrivate,
) (
response *UpdateImageResponses,
err error,
) {
path := client.service + "/images/{imageId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateImageResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ImagePrivate{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes an Image you have permission to `read_write`. Deleting an image is a destructive
// process and cannot be undone. Only private Images are deletable.
//
func (client *Client) DeleteImage() (
response *DeleteImageResponses,
err error,
) {
path := client.service + "/images/{imageId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteImageResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Linodes you have permission to view.
//
func (client *Client) GetLinodeInstaces() (
response *GetLinodeInstacesResponses,
err error,
) {
path := client.service + "/linode/instances"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeInstacesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to create a new Linode server 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. See `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, see `GET /regions` for a list
// of available regions you deploy your Linode in.
//
// Linodes can be created in a number of ways:
//
// - Using a Linode Linux Distribution image or an image you created based on another Linode
// - The Linode will be `running` after it completes `provisioning`
// - A default a 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 `password` 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
//
// - Using one of your own StackScripts or a public StackScript
// - The Linode will be `running` after it completes `provisioning`
// - Requires a compatible Linode Linux Distribution `image` to be supplied
// - see `GET /linode/stackscript/{stackscriptId}` 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
//
// - Using one of your other Linode's backups
// - The Linode will be `running` after it completes `provisioning`
// - 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
//
// - Create an empty Linode
// - The Linode will remain `offline` and must be manually started
// - see `POST /linode/instances/{linodeId}/boot`
// - Disks and Configs must be created manually
// - This is only recommended for advanced use-cases
//
func (client *Client) CreateLinodeInstance(
object interface{},
) (
response *CreateLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Linode{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Get a specific Linode by ID.
func (client *Client) GetLinodeInstance() (
response *GetLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Linode{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This allows you to update a Linode that you have permission to `read_write`.
//
func (client *Client) UpdateLinodeInstance(
linode Linode,
) (
response *UpdateLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Linode{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a Linode you have permission to `read_write`. Deleting a Linode is a destructive
// process and cannot be undone. Additionally, deleting a Linode:
//
// * Gives up any IP addresses the Linode was assigned
// * Deletes all disks, backups, configs, etc.
// * Stops billing for the Linode and its associated services. You will be billed for time used
// within the billing period the Linode was active.
//
func (client *Client) DeleteLinodeInstance() (
response *DeleteLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about this Linode's available backups.
//
func (client *Client) GetBackups() (
response *GetBackupsResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/backups"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetBackupsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a snapshot backup of a Linode. WARNING: If you already have a snapshot this is a destructive operation. The previous snapshot will be deleted.
//
func (client *Client) CreateSnapshot(
object interface{},
) (
response *CreateSnapshotResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/backups"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateSnapshotResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Backup{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Cancels the backup service on the given Linode.
//
func (client *Client) CancelBackups() (
response *CancelBackupsResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/backups/cancel"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CancelBackupsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Enables backups for the specified Linode.
//
func (client *Client) EnableBackups() (
response *EnableBackupsResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/backups/enable"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &EnableBackupsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Return information about a backup.
//
func (client *Client) GetBackup() (
response *GetBackupResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/backups/{backupId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetBackupResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Backup{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Restores a Linode's backup to the specified Linode.
//
func (client *Client) RestoreBackup(
object interface{},
) (
response *RestoreBackupResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/backups/{backupId}/restore"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &RestoreBackupResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// 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.
//
func (client *Client) BootLinodeInstance(
object interface{},
) (
response *BootLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/boot"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &BootLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// 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.
//
func (client *Client) RebootLinodeInstance() (
response *RebootLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/reboot"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &RebootLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// 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.
//
func (client *Client) ShutdownLinodeInstance() (
response *ShutdownLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/shutdown"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ShutdownLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// 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.
//
func (client *Client) MutateLinodeInstance() (
response *MutateLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/mutate"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &MutateLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// 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:
//
// * Any pending free upgrades to the Linode's current type must be performed
// before a resize can occur.
// * 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.
//
func (client *Client) ResizeLinodeInstance(
object interface{},
) (
response *ResizeLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/resize"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ResizeLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to rebuild a Linode if you have the `read_write` permission for it. If any actions are currently running or queued, those actions must be completed first before you can initiate a rebuild.
// 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.
//
func (client *Client) RebuildLinodeInstance(
object interface{},
) (
response *RebuildLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/rebuild"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &RebuildLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Linode{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// 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.
//
func (client *Client) RescueLinodeInstance(
object interface{},
) (
response *RescueLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/rescue"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &RescueLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// 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.
//
func (client *Client) CloneLinodeInstance(
object interface{},
) (
response *CloneLinodeInstanceResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/clone"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CloneLinodeInstanceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns networking information for a single Linode.
//
func (client *Client) GetLinodeIPs() (
response *GetLinodeIPsResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/ips"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeIPsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Allocate a public or private IPv4 address to a Linode. Public IP Addresses, over and above 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 ticket. One may not add more than one private IPv4 address to a single Linode.
//
func (client *Client) AddLinodeIP() (
response *AddLinodeIPResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/ips"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &AddLinodeIPResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &IPAddress{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// View information about the specified IP address associated with the specified Linode.
//
func (client *Client) GetLinodeIP() (
response *GetLinodeIPResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/ips/{address}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeIPResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &IPAddress{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Manage a particular IP Address associated with this Linode. Currently only allows setting/resetting reverse DNS.
//
func (client *Client) UpdateLinodeIP(
object interface{},
) (
response *UpdateLinodeIPResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/ips/{address}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateLinodeIPResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &IPAddress{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Delete a public IPv4 address associated with this Linode. This will fail if it is the Linode's last remaining IP address. Private IPv4 addresses cannot be removed via this endpoint.
//
func (client *Client) RemoveLinodeIP() (
response *RemoveLinodeIPResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/ips/{address}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &RemoveLinodeIPResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// View Block Storage Volumes attached to this Linode.
//
func (client *Client) GetLinodeVolumes() (
response *GetLinodeVolumesResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/volumes"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeVolumesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Lists configuration profiles associated with a Linode.
//
func (client *Client) GetLinodeConfigs() (
response *GetLinodeConfigsResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/configs"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeConfigsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Adds a new configuration profile to a Linode.
//
func (client *Client) AddLinodeConfig(
linodeconfig LinodeConfig,
) (
response *AddLinodeConfigResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/configs"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(linodeconfig)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &AddLinodeConfigResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LinodeConfig{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a specific configuration profile.
//
func (client *Client) GetLinodeConfig() (
response *GetLinodeConfigResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/configs/{configId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeConfigResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LinodeConfig{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates the parameters of a single configuration profile.
//
func (client *Client) UpdateLinodeConfig(
linodeconfig LinodeConfig,
) (
response *UpdateLinodeConfigResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/configs/{configId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateLinodeConfigResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LinodeConfig{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes the specified configuration profile from the specified Linode.
//
func (client *Client) DELETE_linode_instances_linodeId_configs_configId() (
response *DELETE_linode_instances_linodeId_configs_configIdResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/configs/{configId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DELETE_linode_instances_linodeId_configs_configIdResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// View Disk information for disks associated with this Linode.
//
func (client *Client) GetLinodeDisks() (
response *GetLinodeDisksResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/disks"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeDisksResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Adds a new disk to a Linode. You can optionally create a disk from an image (see `GET /images` for a list of available public images, or use one of your own), and optionally provide a StackScript to deploy with this Disk.
//
func (client *Client) AddLinodeDisk(
diskrequest DiskRequest,
) (
response *AddLinodeDiskResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/disks"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(diskrequest)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &AddLinodeDiskResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Disk{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// View Disk information for a disk associated with this Linode.
//
func (client *Client) GetLinodeDisk() (
response *GetLinodeDiskResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/disks/{diskId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeDiskResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Disk{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This allows you to update a Disk that you have permission to `read_write`.
//
func (client *Client) UpdateDisk(
disk Disk,
) (
response *UpdateDiskResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/disks/{diskId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateDiskResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Disk{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a Disk you have permission to `read_write`. Deleting a Disk is a
// destructive process and cannot be undone.
//
func (client *Client) DeleteDisk() (
response *DeleteDiskResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/disks/{diskId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteDiskResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to reset the password of a disk you have permission to `read_write`.
//
func (client *Client) ResetDiskPassword(
object interface{},
) (
response *ResetDiskPasswordResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/disks/{diskId}/password"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ResetDiskPasswordResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to resize a disk you have permission to `read_write`.
// The Linode this Disk is attached to must be shut down for resizing to take effect.
// 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.
//
func (client *Client) ResizeDisk(
object interface{},
) (
response *ResizeDiskResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/disks/{diskId}/resize"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ResizeDiskResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns CPU, IO, IPv4, and IPv6 statistics for your Linode for the past 24 hours.
//
func (client *Client) GetLinodeStats() (
response *GetLinodeStatsResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/stats"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeStatsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LinodeStats{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint 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.
//
func (client *Client) GetLinodeStatsByYearMonth() (
response *GetLinodeStatsByYearMonthResponses,
err error,
) {
path := client.service + "/linode/instances/{linodeId}/stats/{year}/{month}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeStatsByYearMonthResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LinodeStats{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Lists available kernels.
//
func (client *Client) GetKernels() (
response *GetKernelsResponses,
err error,
) {
path := client.service + "/linode/kernels"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetKernelsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Get information about a single kernel.
//
func (client *Client) GetKernel() (
response *GetKernelResponses,
err error,
) {
path := client.service + "/linode/kernels/{kernelId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetKernelResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Kernel{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a list of publicly available StackScripts. If the request is authenticated, the list also includes private StackScripts the user has permissions to view.
//
func (client *Client) GetStackScripts() (
response *GetStackScriptsResponses,
err error,
) {
path := client.service + "/linode/stackscripts"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetStackScriptsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to add a new StackScript to your account.
//
func (client *Client) AddStackScript(
stackscript StackScript,
) (
response *AddStackScriptResponses,
err error,
) {
path := client.service + "/linode/stackscripts"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(stackscript)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &AddStackScriptResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &StackScript{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns all of the information about a specified StackScript, including the contents of the script.
//
func (client *Client) GetStackScript() (
response *GetStackScriptResponses,
err error,
) {
path := client.service + "/linode/stackscripts/{stackscriptId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetStackScriptResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &StackScript{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to modify a StackScript. Setting a StackScript to public is a permanent change.
//
func (client *Client) UpdateStackScript() (
response *UpdateStackScriptResponses,
err error,
) {
path := client.service + "/linode/stackscripts/{stackscriptId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateStackScriptResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &StackScript{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to permanently delete a specific StackScript. You cannot delete a public StackScript.
//
func (client *Client) DeleteStackScript() (
response *DeleteStackScriptResponses,
err error,
) {
path := client.service + "/linode/stackscripts/{stackscriptId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteStackScriptResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns collection of Linode types, including pricing and specifications for each type. These are used when creating or resizing Linodes.
//
func (client *Client) GetLinodeTypes() (
response *GetLinodeTypesResponses,
err error,
) {
path := client.service + "/linode/types"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeTypesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a specific Linode type, including pricing and specifications. This is used when creating or resizing a Linode.
//
func (client *Client) GetLinodeType() (
response *GetLinodeTypeResponses,
err error,
) {
path := client.service + "/linode/types/{typeId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLinodeTypeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LinodeType{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Managed Contacts on your account.
//
func (client *Client) GetManagedContacts() (
response *GetManagedContactsResponses,
err error,
) {
path := client.service + "/managed/contacts"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedContactsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new Managed Contact. A Managed Contact is someone Linode special forces can contact in the course of attempting to resolve an issue with a Managed Service.
//
func (client *Client) CreateManagedContact(
managedcontact ManagedContact,
) (
response *CreateManagedContactResponses,
err error,
) {
path := client.service + "/managed/contacts"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(managedcontact)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateManagedContactResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedContact{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single Managed Contact.
//
func (client *Client) GetManagedContact() (
response *GetManagedContactResponses,
err error,
) {
path := client.service + "/managed/contacts/{contactId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedContactResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedContact{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates information about a Managed Contact.
//
func (client *Client) UpdateManagedContact(
managedcontact ManagedContact,
) (
response *UpdateManagedContactResponses,
err error,
) {
path := client.service + "/managed/contacts/{contactId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateManagedContactResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedContact{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a Managed Contact.
//
func (client *Client) DeleteManagedContact() (
response *DeleteManagedContactResponses,
err error,
) {
path := client.service + "/managed/contacts/{contactId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteManagedContactResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Managed Credentials on your account.
//
func (client *Client) GetManagedCredentials() (
response *GetManagedCredentialsResponses,
err error,
) {
path := client.service + "/managed/credentials"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedCredentialsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new Managed Credential. A Managed Credential is stored securely to allow Linode special forces to access your Managed Services and resolve issues.
//
func (client *Client) CreateManagedCredential(
object interface{},
) (
response *CreateManagedCredentialResponses,
err error,
) {
path := client.service + "/managed/credentials"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateManagedCredentialResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedCredential{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single Managed Credential.
//
func (client *Client) GetManagedCredential() (
response *GetManagedCredentialResponses,
err error,
) {
path := client.service + "/managed/credentials/{credentialId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedCredentialResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedCredential{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates information about a Managed Credential.
//
func (client *Client) UpdateManagedCredential(
managedcredential ManagedCredential,
) (
response *UpdateManagedCredentialResponses,
err error,
) {
path := client.service + "/managed/credentials/{credentialId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateManagedCredentialResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedCredential{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a Managed Credential. Linode special forces will no longer have access to this credential when attempting to resolve issues.
//
func (client *Client) DeleteManagedCredential() (
response *DeleteManagedCredentialResponses,
err error,
) {
path := client.service + "/managed/credentials/{credentialId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteManagedCredentialResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of recent and ongoing issues detected on your Managed Services.
//
func (client *Client) GetManagedIssues() (
response *GetManagedIssuesResponses,
err error,
) {
path := client.service + "/managed/issues"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedIssuesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single issue that is impacting or did impact one of your Managed Services.
//
func (client *Client) GetManagedIssue() (
response *GetManagedIssueResponses,
err error,
) {
path := client.service + "/managed/issues/{issueId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedIssueResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedIssue{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Managed settings for your Linodes. There will be one entry per Linode on your account.
//
func (client *Client) GetManagedLinodeSettings() (
response *GetManagedLinodeSettingsResponses,
err error,
) {
path := client.service + "/managed/linode-settings"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedLinodeSettingsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single Linode's Managed settings.
//
func (client *Client) GetManagedLinodeSetting() (
response *GetManagedLinodeSettingResponses,
err error,
) {
path := client.service + "/managed/linode-settings/{linodeId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedLinodeSettingResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedLinodeSettings{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates a single Linode's Managed settings.
//
func (client *Client) UpdateManagedLinodeSetting(
managedlinodesettings ManagedLinodeSettings,
) (
response *UpdateManagedLinodeSettingResponses,
err error,
) {
path := client.service + "/managed/linode-settings/{linodeId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateManagedLinodeSettingResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedLinodeSettings{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Managed Services on your account. These are the services Linode Managed is monitoring and will report and attempt to resolve issues with.
//
func (client *Client) GetManagedServices() (
response *GetManagedServicesResponses,
err error,
) {
path := client.service + "/managed/services"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedServicesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new Managed Service. Linode Managed will being monitoring this service and reporting and attempting to resolve any issues.
//
func (client *Client) CreateManagedService(
object interface{},
) (
response *CreateManagedServiceResponses,
err error,
) {
path := client.service + "/managed/services"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateManagedServiceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedService{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a single Managed Service on your account.
//
func (client *Client) GetManagedService() (
response *GetManagedServiceResponses,
err error,
) {
path := client.service + "/managed/services/{serviceId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetManagedServiceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedService{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates information about a Managed Service.
//
func (client *Client) UpdateManagedService(
managedservice ManagedService,
) (
response *UpdateManagedServiceResponses,
err error,
) {
path := client.service + "/managed/services/{serviceId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateManagedServiceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedService{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a Managed Service. This service will no longer be monitored by Linode Managed.
//
func (client *Client) DeleteManagedService() (
response *DeleteManagedServiceResponses,
err error,
) {
path := client.service + "/managed/services/{serviceId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteManagedServiceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Temporarily disables monitoring of a Managed Service.
//
func (client *Client) DisableManagedService() (
response *DisableManagedServiceResponses,
err error,
) {
path := client.service + "/managed/services/{serviceId}/disable"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DisableManagedServiceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedService{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Re-enables monitoring of a Managed Service.
//
func (client *Client) EnableManagedService() (
response *EnableManagedServiceResponses,
err error,
) {
path := client.service + "/managed/services/{serviceId}/enable"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &EnableManagedServiceResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &ManagedService{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of IP Addresses on your account, excluding private addresses.
//
func (client *Client) GetIPs() (
response *GetIPsResponses,
err error,
) {
path := client.service + "/networking/ips"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetIPsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Allocates a new IP Address on your account. Currently, only IPv4 addresses may be allocated this way. The Linode you are allocating this address for must be allowed to allocate additional addresses - please open a support ticket requesting additional addresses before attempting allocation.
//
func (client *Client) AllocateIP(
object interface{},
) (
response *AllocateIPResponses,
err error,
) {
path := client.service + "/networking/ips"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &AllocateIPResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &IPAddress{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a single IP Address on your account.
//
func (client *Client) GetIP() (
response *GetIPResponses,
err error,
) {
path := client.service + "/networking/ips/{address}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetIPResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &IPAddress{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Sets RDNS on an IP Address. Forward DNS must already be set up for reverse DNS to be applied. If you set the RDNS to `null` for public ipv4 addresses, it will be reset to the default members.linode.com RDNS value.
//
func (client *Client) UpdateIP(
ipaddress IPAddress,
) (
response *UpdateIPResponses,
err error,
) {
path := client.service + "/networking/ips/{address}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateIPResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &IPAddress{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Longview Clients you have access to. Longview Clients are used to monitor stats on your servers with the help of the Longview Client application.
//
func (client *Client) GetLongviewClients() (
response *GetLongviewClientsResponses,
err error,
) {
path := client.service + "/longview/clients"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLongviewClientsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Create a new Longview Client. This client will not begin monitoring the status of one of your servers until you configure the Longview Client application on your server using the returning `install_code` and `api_key`.
//
func (client *Client) CreateLongviewClient(
longviewclient LongviewClient,
) (
response *CreateLongviewClientResponses,
err error,
) {
path := client.service + "/longview/clients"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(longviewclient)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateLongviewClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LongviewClient{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single Longview Client you can access.
//
func (client *Client) GetLongviewClient() (
response *GetLongviewClientResponses,
err error,
) {
path := client.service + "/longview/clients/{clientId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLongviewClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LongviewClient{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates a Longview Client. This cannot update how it monitors your server - use the Longview Client application on your server for monitoring configuration.
//
func (client *Client) UpdateLongviewClient(
longviewclient LongviewClient,
) (
response *UpdateLongviewClientResponses,
err error,
) {
path := client.service + "/longview/clients/{clientId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateLongviewClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LongviewClient{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a Longview Client from your account. All information stored for this client will be lost. This _does not_ uninstall the Longview Client application for your server - you must do that manually.
//
func (client *Client) DeleteLongviewClient() (
response *DeleteLongviewClientResponses,
err error,
) {
path := client.service + "/longview/clients/{clientId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteLongviewClientResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of available Longview Subscriptions. This is a public endpoint, and requires no authentication.
//
func (client *Client) GetLongviewSubscriptions() (
response *GetLongviewSubscriptionsResponses,
err error,
) {
path := client.service + "/longview/subscriptions"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLongviewSubscriptionsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single LongviewSubscription object. This is a public endpoint and requires no authentication.
//
func (client *Client) GetLongviewSubscription() (
response *GetLongviewSubscriptionResponses,
err error,
) {
path := client.service + "/longview/subscriptions/{subscriptionId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetLongviewSubscriptionResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &LongviewSubscription{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Assign multiple IPs to multiple Linodes in one region. This allows swapping, shuffling, or otherwise reorganizing v4 IP Addresses to your Linodes. When the assignment is finished, all Linodes must end up with at least one public ipv4 and no more than one private ipv4.
//
func (client *Client) AssignIPs(
object interface{},
) (
response *AssignIPsResponses,
err error,
) {
path := client.service + "/networking/ipv4/assign"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &AssignIPsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Configure shared IPs. A shared IP may be brought up on a Linode other than the one it lists in its response. This can be used to allow one Linode to begin serving requests should another become unresponsive.
//
func (client *Client) ShareIPs(
object interface{},
) (
response *ShareIPsResponses,
err error,
) {
path := client.service + "/networking/ipv4/share"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ShareIPsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Displays the IPv6 pools on your account.
//
func (client *Client) GetIPv6Pools() (
response *GetIPv6PoolsResponses,
err error,
) {
path := client.service + "/networking/ipv6/pools"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetIPv6PoolsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Displays the IPv6 ranges on your account.
//
func (client *Client) GetIPv6Ranges() (
response *GetIPv6RangesResponses,
err error,
) {
path := client.service + "/networking/ipv6/ranges"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetIPv6RangesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of NodeBalancers you have access to.
//
func (client *Client) GetNodeBalancers() (
response *GetNodeBalancersResponses,
err error,
) {
path := client.service + "/nodebalancers"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetNodeBalancersResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new NodeBalancer in the requested region. This NodeBalancer will not start serving requests until it is configured.
//
func (client *Client) CreateNodeBalancer(
object interface{},
) (
response *CreateNodeBalancerResponses,
err error,
) {
path := client.service + "/nodebalancers"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateNodeBalancerResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancer{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single NodeBalancer you can access.
//
func (client *Client) GetNodeBalancer() (
response *GetNodeBalancerResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetNodeBalancerResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancer{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update information about a NodeBalancer you can access.
//
func (client *Client) UpdateNodeBalancer(
nodebalancer NodeBalancer,
) (
response *UpdateNodeBalancerResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateNodeBalancerResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancer{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a NodeBalancer. This cannot be undone. Deleting a NodeBalancer will also delete all associated configs and nodes, although the backend servers represented by the nodes will not be changed or removed. Deleting a NodeBalancer will cause you to lose access to the IP Addresses that NodeBalancer was assigned.
//
func (client *Client) DeleteNodeBalancer() (
response *DeleteNodeBalancerResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteNodeBalancerResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of NodeBalancerConfigs associated with this NodeBalancer. NodeBalancer configs represent individual ports that this NodeBalancer will accept traffic on, one config per port. For example, if you wanted to accept standard http traffic, you would need a config listening on port 80.
//
func (client *Client) GetNodeBalancerConfigs() (
response *GetNodeBalancerConfigsResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetNodeBalancerConfigsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new NodeBalancerConfig, which allows the NodeBalancer to accept traffic on a new port. You will need to add NodeBalancerNodes to the new config before it can actually serve requests.
//
func (client *Client) CreateaNodeBalancerConfig(
nodebalancerconfig NodeBalancerConfig,
) (
response *CreateaNodeBalancerConfigResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(nodebalancerconfig)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateaNodeBalancerConfigResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancerConfig{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns configuration information for a single port of this NodeBalancer.
//
func (client *Client) GetNodeBalancerConfig() (
response *GetNodeBalancerConfigResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetNodeBalancerConfigResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancerConfig{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update the configuration for a single port on a NodeBalancer.
//
func (client *Client) UpdateNodeBalancerConfig(
nodebalancerconfig NodeBalancerConfig,
) (
response *UpdateNodeBalancerConfigResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateNodeBalancerConfigResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancerConfig{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes the configuration for a port of this NodeBalancer. This cannot be undone. Once completed, this NodeBalancer will no longer respond to requests on the given port. This also deletes all associated NodeBalancerNodes, but the Linodes they were routing traffic to are unchanged and not removed.
//
func (client *Client) DeleteNodeBalancerConfig() (
response *DeleteNodeBalancerConfigResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteNodeBalancerConfigResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of NodeBalancer nodes associated with this config. These are the backends that will be sent traffic for this port.
//
func (client *Client) GetNodeBalancerConfigNodes() (
response *GetNodeBalancerConfigNodesResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetNodeBalancerConfigNodesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new NodeBalancer node, a backend that can accept traffic, for this NodeBalancer config. Nodes are routed requests on the configured port based on their status.
//
func (client *Client) CreateNodeBalancerNode(
object interface{},
) (
response *CreateNodeBalancerNodeResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateNodeBalancerNodeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancerNode{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a single node, a backend for this NodeBalancer's configured port.
//
func (client *Client) GetNodeBalancerNode() (
response *GetNodeBalancerNodeResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes/{nodeId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetNodeBalancerNodeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancerNode{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates information about a node, a backend for this NodeBalancer's configured port.
//
func (client *Client) UpdateNodeBalancerNode(
nodebalancernode NodeBalancerNode,
) (
response *UpdateNodeBalancerNodeResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes/{nodeId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateNodeBalancerNodeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &NodeBalancerNode{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a node from this config. Is backend will no longer receive traffic for the configured port of this NodeBalancer. This does not change or remove the server whose address was used in the creation of this node.
//
func (client *Client) DeleteNodeBalancerConfigNode() (
response *DeleteNodeBalancerConfigNodeResponses,
err error,
) {
path := client.service + "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes/{nodeId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteNodeBalancerConfigNodeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Lists the regions available for Linode services. Not all services are guaranteed to be
// available in all regions.
//
func (client *Client) GetRegions() (
response *GetRegionsResponses,
err error,
) {
path := client.service + "/regions"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetRegionsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Get information about a single Region.
//
func (client *Client) GetRegion() (
response *GetRegionResponses,
err error,
) {
path := client.service + "/regions/{regionId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetRegionResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Region{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Volumes you have permission to view.
//
func (client *Client) GetVolumes() (
response *GetVolumesResponses,
err error,
) {
path := client.service + "/volumes"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetVolumesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to create a new Volume on your account. In order for this to complete successfully, your user must have the `add_volumes` grant. Creating a new Volume will start accruing additional charges on your account.
// Volume service may not be available in all regions. See `GET /regions` for a list of available regions you deploy your Volume in.
//
func (client *Client) CreateVolume(
object interface{},
) (
response *CreateVolumeResponses,
err error,
) {
path := client.service + "/volumes"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Volume{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Get information about a single Volume.
//
func (client *Client) GetVolume() (
response *GetVolumeResponses,
err error,
) {
path := client.service + "/volumes/{volumeId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Volume{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This allows you to update a Volume that you have permission to `read_write`.
//
func (client *Client) UpdateVolume(
object interface{},
) (
response *UpdateVolumeResponses,
err error,
) {
path := client.service + "/volumes/{volumeId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Volume{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a Volume you have permission to `read_write`. Deleting a Volume
// is a destructive process and cannot be undone. Additionally, deleting
// stops billing for the Volume. You will be billed for time used within
// the billing period the Volume was active.
//
func (client *Client) DeleteVolume() (
response *DeleteVolumeResponses,
err error,
) {
path := client.service + "/volumes/{volumeId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to attach a Volume on your account to an existing Linode on your account. In order for this request to complete successfully, your user must have `read_only` or `read_write` permission to the Volume and `read_write` permission to the Linode. Additionally, the Volume and Linode must be located in the same region.
//
func (client *Client) AttachVolume(
object interface{},
) (
response *AttachVolumeResponses,
err error,
) {
path := client.service + "/volumes/{volumeId}/attach"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &AttachVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to create a new Volume on your account. In order for this request to complete successfully, your user must have the `add_volumes` grant. The new Volume will have the same size and data as the source Volume. Creating a new Volume will incur a charge on your account.
//
func (client *Client) CloneVolume(
object interface{},
) (
response *CloneVolumeResponses,
err error,
) {
path := client.service + "/volumes/{volumeId}/clone"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CloneVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to detach a Volume on your account from a Linode on your account. In order for this request to complete successfully, your user must have `read_write` access to the Volume and `read_write` access to the Linode.
//
func (client *Client) DetachVolume() (
response *DetachVolumeResponses,
err error,
) {
path := client.service + "/volumes/{volumeId}/detach"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DetachVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to resize an existing Volume on your account. In order for this request to complete successfully, your user must have the `read_write` permissions to the Volume.
// * Volumes can only be resized up.
//
func (client *Client) ResizeVolume(
object interface{},
) (
response *ResizeVolumeResponses,
err error,
) {
path := client.service + "/volumes/{volumeId}/resize"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &ResizeVolumeResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of records configured on a domain in Linode's
// DNS Manager.
//
func (client *Client) GetDomainRecords() (
response *GetDomainRecordsResponses,
err error,
) {
path := client.service + "/domains/{domainId}/records"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetDomainRecordsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Adds a new domain record to the zonefile this domain represents.
//
func (client *Client) POST_domains_domainId_records(
domainrecord DomainRecord,
) (
response *POST_domains_domainId_recordsResponses,
err error,
) {
path := client.service + "/domains/{domainId}/records"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(domainrecord)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &POST_domains_domainId_recordsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &DomainRecord{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// View a single record on this domain.
//
func (client *Client) GET_domains_domainId_records_recordId() (
response *GET_domains_domainId_records_recordIdResponses,
err error,
) {
path := client.service + "/domains/{domainId}/records/{recordId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GET_domains_domainId_records_recordIdResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &DomainRecord{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update a single record on this domain.
//
func (client *Client) PUT_domains_domainId_records_recordId(
domainrecord DomainRecord,
) (
response *PUT_domains_domainId_records_recordIdResponses,
err error,
) {
path := client.service + "/domains/{domainId}/records/{recordId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &PUT_domains_domainId_records_recordIdResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &DomainRecord{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Deletes a record on this domain.
//
func (client *Client) DELETE_domains_domainId_records_recordId() (
response *DELETE_domains_domainId_records_recordIdResponses,
err error,
) {
path := client.service + "/domains/{domainId}/records/{recordId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DELETE_domains_domainId_records_recordIdResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about the current user. This can be used to see who is acting in applications where more than one token is managed, for example in third-party OAuth applications. This endpoint is always accessible, no matter what OAuth scopes the acting token has.
//
func (client *Client) GetProfile() (
response *GetProfileResponses,
err error,
) {
path := client.service + "/profile"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetProfileResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Profile{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Update information in your profile. This option is _not_ available to all third-party clients.
//
func (client *Client) UpdateProfile(
profile Profile,
) (
response *UpdateProfileResponses,
err error,
) {
path := client.service + "/profile"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdateProfileResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &Profile{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This is a collection of OAuth apps that you've given access to your account, and includes the level of access granted.
//
func (client *Client) GetProfileApps() (
response *GetProfileAppsResponses,
err error,
) {
path := client.service + "/profile/apps"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetProfileAppsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns information about a single app you've authorized to access your account.
//
func (client *Client) GetProfileApp() (
response *GetProfileAppResponses,
err error,
) {
path := client.service + "/profile/apps/{appId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetProfileAppResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &AuthorizedApp{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Expires all tokens and refresh tokens possessed by this app. This app is no longer authorized to access your account.
//
func (client *Client) DeleteProfileApp() (
response *DeleteProfileAppResponses,
err error,
) {
path := client.service + "/profile/apps/{appId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeleteProfileAppResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This returns a GrantsResponse describing what the acting user has been granted access to. For unrestricted users, this will return a 204 and no body because unrestricted users have access to everything without grants. This will not return information about entities you do not have access to. This endpoint is useful when writing third-party OAuth applications to see what options you should present to the acting user (for example, if they do not have `global.add_linodes`, you might not display a button to deploy a new Linode). Any client may access this endpoint, as no OAuth scopes are required.
//
func (client *Client) GetProfileGrants() (
response *GetProfileGrantsResponses,
err error,
) {
path := client.service + "/profile/grants"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetProfileGrantsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &GrantsResponse{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Generates a Two Factor secret for your user.. TFA will not be enabled until you have successfully confirmed the code you were given with the `tfa-enable-confirm` endpoint (see below). Once enabled, login from untrusted computers will be required to provide a TFA code before they are successful.
//
func (client *Client) TfaEnable() (
response *TfaEnableResponses,
err error,
) {
path := client.service + "/profile/tfa-enable"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &TfaEnableResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Confirms that you can successfully generate Two Factor codes and enables TFA on your account. Once this is complete, login attempts from untrusted computers will be required to provide a Two Factor code before they are successful.
//
func (client *Client) TfaConfirm(
object interface{},
) (
response *TfaConfirmResponses,
err error,
) {
path := client.service + "/profile/tfa-enable-confirm"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &TfaConfirmResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Disabled Two Factor Authentication for your user. Once successful, login attempts from untrusted computers will only require a password before being successful. This is less secure, and is discouraged.
//
func (client *Client) TfaDisable() (
response *TfaDisableResponses,
err error,
) {
path := client.service + "/profile/tfa-disable"
body := new(bytes.Buffer)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &TfaDisableResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a paginated list of Personal Access Tokens currently active for your user.
//
func (client *Client) GetPersonalAccessTokens() (
response *GetPersonalAccessTokensResponses,
err error,
) {
path := client.service + "/profile/tokens"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetPersonalAccessTokensResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Creates a new Personal Access Token for your user. The raw token will be returned in the response, but will never be returned again afterward so be sure to take note of it. You may create a token with _at most_ the scopes of your current token. The created token will be able to access your account until the given expiry, or until it is revoked.
//
func (client *Client) CreatePersonalAccessToken(
object interface{},
) (
response *CreatePersonalAccessTokenResponses,
err error,
) {
path := client.service + "/profile/tokens"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreatePersonalAccessTokenResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &PersonalAccessToken{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Returns a single Personal Access Token.
//
func (client *Client) GetPersonalAccessToken() (
response *GetPersonalAccessTokenResponses,
err error,
) {
path := client.service + "/profile/tokens/{tokenId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetPersonalAccessTokenResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &PersonalAccessToken{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Updates a Personal Access Token's label.
//
func (client *Client) UpdatePersonalAccessToken(
personalaccesstoken PersonalAccessToken,
) (
response *UpdatePersonalAccessTokenResponses,
err error,
) {
path := client.service + "/profile/tokens/{tokenId}"
req, err := http.NewRequest("PUT", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &UpdatePersonalAccessTokenResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &PersonalAccessToken{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Immediately revokes a Personal Access Token. The token will be invalidated immediately, and requests using that token will fail with a 401. It _is_ possible to revoke access to the token making the request to revoke a token, but keep in mind that doing so could lose you access to the api and require you to create a new token through some other means.
//
func (client *Client) DeletePersonalAccessToken() (
response *DeletePersonalAccessTokenResponses,
err error,
) {
path := client.service + "/profile/tokens/{tokenId}"
req, err := http.NewRequest("DELETE", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &DeletePersonalAccessTokenResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a collection of Support Tickets on your account. Support Tickets can be both tickets you open with Linode for support, as well as tickets generated by Linode and regarding your account.
// This collection includes all Support Tickets generated on your account, with open tickets returned first.
//
func (client *Client) GetTickets() (
response *GetTicketsResponses,
err error,
) {
path := client.service + "/support/tickets"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetTicketsResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// Create a Support Ticket.
// Only one of the ID attributes (`linode_id`, `domain_id`, etc) can be set on a single Support Ticket.
//
func (client *Client) CreateTicket(
supportticketrequest SupportTicketRequest,
) (
response *CreateTicketResponses,
err error,
) {
path := client.service + "/support/tickets"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(supportticketrequest)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateTicketResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &SupportTicket{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a Support Ticket under your account.
//
func (client *Client) GetTicket() (
response *GetTicketResponses,
err error,
) {
path := client.service + "/support/tickets/{ticketId}"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetTicketResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &SupportTicket{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to add a file attachment to an existing Support Ticket on your account. File attachments are used to assist our Support team in resolving your Support Ticket. Examples of attachments are screen shots and text files that provide additional information.
//
func (client *Client) CreateTicketAttachment(
object interface{},
) (
response *CreateTicketAttachmentResponses,
err error,
) {
path := client.service + "/support/tickets/{ticketId}/attachments"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateTicketAttachmentResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint returns a collection of replies to a singular Support Ticket on your account.
//
func (client *Client) GetTicketReplies() (
response *GetTicketRepliesResponses,
err error,
) {
path := client.service + "/support/tickets/{ticketId}/replies"
req, err := http.NewRequest("GET", path, nil)
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &GetTicketRepliesResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := struct{}{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
// This endpoint allows you to add a reply to an existing Support Ticket.
//
func (client *Client) CreateTicketReply(
object interface{},
) (
response *CreateTicketReplyResponses,
err error,
) {
path := client.service + "/support/tickets/{ticketId}/replies"
body := new(bytes.Buffer)
json.NewEncoder(body).Encode(object)
req, err := http.NewRequest("POST", path, body)
reqHeaders := make(http.Header)
reqHeaders.Set("Content-Type", "application/json")
req.Header = reqHeaders
if err != nil {
return
}
resp, err := client.client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New(resp.Status)
}
response = &CreateTicketReplyResponses{}
switch {
case resp.StatusCode == 200:
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
result := &SupportTicketReply{}
err = json.Unmarshal(body, result)
if err != nil {
return nil, err
}
response.OK = result
default:
break
}
return
}
Raw
constants.go
// GENERATED FILE: DO NOT EDIT!
package linode
// ServicePath is the base URL of the service.
const ServicePath = ""
// OAuthScopes lists the OAuth scopes required by the service.
const OAuthScopes = ""
Raw
linodeapi3.yaml
openapi: 3.0.1
info:
version: 4.0.0
title: Linode API V4
description: |
This is Linode's next generation API. The API was designed around the concepts of REST and does
its best to conform to a RESTful model whenever possible. When not possible the goal was to be
as intuitive as possible.
Another design goal of the Linode API was to give developers the power to manipulate all Linode
services through code as easily as they can through the Linode Manager UI.
With this API, it is now not only possible to create a new Linode, but also enable backups,
add it to a Nodebalancer, attach Block Storage Volumes, create backup snapshots, imagize its
disk for mass deployment of more Linodes, and so much more.
Additionally, as an administrator on an account, you can now use the API to create new users and
control the level of access they have to the services on your account.
Finally, one of the most powerful features of this version of Linode's API is the ability to
allow third-party applications control of your account through the OAuth 2 protocol. All Linode
service endpoints allow four levels of access: __view__, __create__, __modify__, __delete__.
Developers now have the capability to create their own exciting new services on top of Linode's
world-class infrastructure.
contact:
name: Linode
email: support@linode.com
url: https://www.linode.com
servers:
- url: https://api.linode.com/v4
paths:
/account:
get:
x-linode-grant: read_only
tags:
- account
summary: View your Account information.
description: >
This endpoint returns the contact and billing information related to
your Account.
operationId: getAccount
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a single Account object.
content:
application/json:
schema:
$ref: '#/components/schemas/Account'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- account
summary: Update your Account
description: >
This endpoint allows you to update contact and billing information
related to your Account.
operationId: updateAccount
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Update contact and billing information.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Account'
responses:
'200':
description: The updated Account.
content:
application/json:
schema:
$ref: '#/components/schemas/Account'
default:
$ref: '#/components/responses/ErrorResponse'
/account/credit-card:
post:
x-linode-grant: read_write
tags:
- account
summary: Add/edit the credit card information for your Account.
description: >
This endpoint allows you to add/edit credit card information to your Account.
Only one credit card can be associated with your Account, so using this
endpoint will overwrite your card information with the
new credit card.
operationId: createCreditCard
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Update the credit card information associated with your Account.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/CreditCard'
responses:
'200':
description: Credit Card updated.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/account/events:
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- account
summary: View Events on your Account.
description: >
This endpoint returns a collection of Event objects representing
actions taken on your Account. The events returned depends on your
grants.
operationId: getEvents
security:
- personalAccessToken: []
- oauth:
- events:read_only
responses:
'200':
description: Returns a paginated lists of Event objects.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Event'
default:
$ref: '#/components/responses/ErrorResponse'
/account/events/{eventId}:
parameters:
- name: eventId
in: path
description: The ID of the Event.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- account
summary: View a single Event.
description: Returns a single Event object.
operationId: getEvent
security:
- personalAccessToken: []
- oauth:
- events:read_only
responses:
'200':
description: An Event object
content:
application/json:
schema:
$ref: '#/components/schemas/Event'
default:
$ref: '#/components/responses/ErrorResponse'
/account/events/{eventId}/read:
parameters:
- name: eventId
in: path
description: The ID of the Event to designate as read.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
tags:
- account
summary: Update a specific Event to designate that it has been read.
description: Marks Event as read.
operationId: eventRead
security:
- personalAccessToken: []
- oauth:
- events:read_write
responses:
'200':
description: Event read.
content:
applicaton/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/account/events/{eventId}/seen:
parameters:
- name: eventId
in: path
description: The ID of the Event to designate as seen.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
tags:
- account
summary: Updates Events to designate that they have been seen.
description: >
Marks all Events up to and including this Event by ID as seen.
operationId: eventSeen
security:
- personalAccessToken: []
- oauth:
- events:read_only
responses:
'200':
description: Events seen.
content:
applicaton/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/account/invoices:
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- account
summary: View your Account invoices.
description: >
This endpoint returns a paginated list of invoices against your Account.
operationId: getInvoices
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a paginated list of Invoice objects.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Invoice'
default:
$ref: '#/components/responses/ErrorResponse'
/account/invoices/{invoiceId}:
parameters:
- name: invoiceId
in: path
description: The ID of the Invoice.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- account
summary: View a single Invoice.
description: Returns a single Invoice object.
operationId: getInvoice
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: An Invoice object
content:
application/json:
schema:
$ref: '#/components/schemas/Invoice'
default:
$ref: '#/components/responses/ErrorResponse'
/account/invoices/{invoiceId}/items:
parameters:
- name: invoiceId
in: path
description: The ID of the Invoice.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- account
summary: Returns a paginated list of InvoiceItem objects identified by `invoiceId`.
description: Returns a paginated list of Invoice items.
operationId: getInvoiceItems
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A paginated list of InvoiceItem objects
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/InvoiceItem'
default:
$ref: '#/components/responses/ErrorResponse'
/account/notifications:
get:
x-linode-grant: read_only
tags:
- account
summary: View Notifications on your Account.
description: >
This endpoint returns a collection of Notification objects representing
important, often time-sensitive items related to your account.
You cannot interact directly with Notifications, and it will disappear
when the circumstances causing the Notification have been resolved. For
example, if you have an important ticket open, you must respond to the
ticket to dismiss the Notification.
operationId: getNotifications
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a paginated list of Notification objects.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Notification'
default:
$ref: '#/components/responses/ErrorResponse'
/account/oauth-clients:
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- account
summary: View OAuth Clients on your account.
description: >
Returns a paginated list of OAuth Clients registered to your account. OAuth
Clients allow users to log into applications you write or host using their
Linode account, and may allow them to grant some level of access to their
Linodes or other entities to your application.
operationId: getClients
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A paginated list of OAuth Clients.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/OAuthClient'
default:
$ref: '#/components/responses/ErrorResponse'
post:
tags:
- account
summary: Register a new OAuth Client with Linode.
description: >
Create a new OAuth Client, which can be used to allow users to login to
your own applications using their Linode account, and optionally grant
your application some amount of access to their Linodes or other entities.
operationId: createClient
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Information about the OAuth Client to create.
content:
application/json:
schema:
type: object
required:
- label
- redirect_uri
allOf:
- $ref: '#/components/schemas/OAuthClient'
- properties:
public:
type: boolean
description: Whether to create a public of private client.
example: false
responses:
'200':
description: Client created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/OAuthClient'
default:
$ref: '#/components/responses/ErrorResponse'
/account/oauth-clients/{clientId}:
parameters:
- name: clientId
in: path
description: The OAuth Client ID to look up.
required: true
schema:
type: string
get:
tags:
- account
summary: View a single OAuth Client.
description: >
Returns information about a single OAuth client.
operationId: getClient
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Information about the requested client.
content:
application/json:
schema:
$ref: '#/components/schemas/OAuthClient'
default:
$ref: '#/components/responses/ErrorResponse'
put:
tags:
- account
summary: Update information about an OAuth Client.
description: >
Update information about an OAuth Client on your account. This can be
especially useful to update the redirect_uri of your client in the event
that the callback url changed in your application.
operationId: updateClient
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The fields to update.
content:
application/json:
schema:
$ref: '#/components/schemas/OAuthClient'
responses:
'200':
description: Client updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/OAuthClient'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
tags:
- account
summary: Delete an OAuth Client registered with Linode.
description: >
Deletes an OAuth Client registered with Linode. The Client ID and
Client Secret will no longer be accepted by https://login.linode.com,
and all tokens issued to this client will be invalidated (meaning that
if your application was using a token, it will no longer work).
operationId: deleteClient
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Client deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/account/oauth-clients/{clientId}/thumbnail:
parameters:
- name: clientId
in: path
description: The OAuth Client ID to look up.
required: true
schema:
type: string
get:
tags:
- account
summary: Returns the thumbnail for this OAuth Client.
description: >
Returns the thumbnail for this OAuth Client. This is a
publicly-viewable endpoint, and can be accessed without authentication.
operationId: getClientThumbnail
responses:
'200':
description: The client's thumbnail.
content:
image/png:
schema:
type: string
format: binary
default:
$ref: '#/components/responses/ErrorResponse'
put:
tags:
- account
summary: Set a OAuth Client's thumbnail.
description: >
Upload a thumbnail for a client you own. You must upload an image file
that will be returned when the thumbnail is retrieved. This image will
be publicly-viewable.
operationId: setClientThumbnail
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The image to set as the thumbnail.
required: true
content:
image/png:
schema:
type: string
format: binary
responses:
'200':
description: Thumbnail updated successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/account/oauth-clients/{clientId}/reset-secret:
parameters:
- name: clientId
in: path
description: The OAuth Client ID to look up.
required: true
schema:
type: string
post:
tags:
- account
summary: Reset the OAuth Client Secret for a client.
description: >
Resets the OAuth Client Secret for a client you own, and returns the
OAuth Client with the plaintext secret. This secret is not supposed to
be publicly known or disclosed anywhere. This can be used to generate
a new secret in case the one you have has been leaked, or to get a new
secret if you lost the original. The old secret is expired immediately,
and logins to your client with the old secret will fail.
operationId: resetClientSecret
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Client Secret reset successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/OAuthClient'
default:
$ref: '#/components/responses/ErrorResponse'
/account/payments:
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
x-linode-grant: read_only
tags:
- account
summary: View Payments made to your Account.
description: >
This endpoint returns a paginated list of Payments made on this Account.
operationId: getPayments
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a paginated list of Payment objects.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Payment'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- account
summary: Make a payment.
description: >
This endpoint allows you to make a payment to your Account
via credit card. This will charge your credit card the requested amount.
operationId: createPayment
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Information about the payment you are making.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PaymentRequest'
responses:
'200':
description: Payment made.
content:
application/json:
schema:
$ref: '#/components/schemas/Payment'
default:
$ref: '#/components/responses/ErrorResponse'
/account/payments/{paymentId}:
parameters:
- name: paymentId
in: path
description: The ID of the Payment to look up.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- account
summary: Returns information about a specific Payment.
description: >
Returns information about a specific Payment.
operationId: getPayment
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A Payment object.
content:
application/json:
schema:
$ref: '#/components/schemas/Payment'
default:
$ref: '#/components/responses/ErrorResponse'
/account/payments/paypal:
post:
x-linode-grant: read_only
tags:
- account
summary: Stage a PayPal payment.
description: >
This begins the process of submitting a payment via PayPal. After calling
this endpoint, you must take the resulting `payment_id` along with
the `payer_id` from your PayPal account, and POST to
`/account/payments/paypal-execute` to complete the payment.
operationId: createPayPalPayment
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: >
The amount to submit as payment via PayPal.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PayPal'
responses:
'200':
description: PayPal payment staged.
content:
application/json:
schema:
$ref: '#/components/schemas/PayPalExecute'
default:
$ref: '#/components/responses/ErrorResponse'
/account/payment/paypal/execute:
post:
x-linode-grant: read_write
tags:
- account
summary: Execute a staged and approved PayPal payment.
description: >
Given a PaymentID and PayerID - as generated by PayPal during the
transaction authorization process - this endpoint executes the payment
to capture the funds and credit your Linode account.
operationId: executePayPalPayment
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: >
The details of the payment to execute.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PayPalExecute'
responses:
'200':
description: PayPal payment executed.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/account/settings:
get:
x-linode-grant: read_only
tags:
- account
summary: View your Account settings information.
description: >
This endpoint returns information related to
your Account settings: Managed service subscription, Longview
subscription, and network helper.
operationId: getAccountSettings
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a single Account settings object.
content:
application/json:
schema:
$ref: '#/components/schemas/AccountSettings'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- account
summary: Update your Account Settings
description: >
This endpoint allows you to update your Account settings.
operationId: updateAccountSettings
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Update Account settings information.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/AccountSettings'
responses:
'200':
description: The updated Account settings.
content:
application/json:
schema:
$ref: '#/components/schemas/AccountSettings'
default:
$ref: '#/components/responses/ErrorResponse'
/account/users:
get:
x-linode-grant: unrestricted only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- account/users
summary: View users on your account.
description: >
Returns a paginated list of Users on your account. Users may access all
or part of your account based on their restricted status and grants. An
unrestricted user may access everything on the account, whereas restricted
user may only access entities or perform actions they've been given specific
grants to.
operationId: getUsers
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A paginated list of Users.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/User'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: unrestricted only
tags:
- account/users
summary: Create a new User on your account.
description: >
Creates a new User on your account. Once created, the user will be
able to log in and access portions of your account. Access is
determined by whether or not they are restricted, and what grants they
have been given.
operationId: createUser
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Information about the User to create.
content:
application/json:
schema:
type: object
required:
- username
- email
- password
allOf:
- $ref: '#/components/schemas/User'
- properties:
email:
type: string
format: email
description: >
The new user's email address.
example: example_user@linode.com
password:
type: string
description: >
The password this user will user to log in.
example: hunter7
format: password
responses:
'200':
description: New user created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/User'
default:
$ref: '#/components/responses/ErrorResponse'
/account/users/{username}:
parameters:
- name: username
in: path
description: The username to look up.
required: true
schema:
type: string
get:
x-linode-grant: unrestricted only
tags:
- account/users
summary: View a single user.
description: >
Returns information about a single user on your account.
operationId: getUser
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: The requested User object
content:
application/json:
schema:
$ref: '#/components/schemas/User'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: unrestricted only
tags:
- account/users
summary: Update a user's information.
description: >
Update information about a user on your account. This can be used to
change the restricted status of a user. When making a user restricted,
no grants will be configured by default and you must then set up grants
in order for the user to access anything on the account.
operationId: updateUser
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The information to update.
content:
application/json:
schema:
$ref: '#/components/schemas/User'
responses:
'200':
description: User updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/User'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: unrestricted only
tags:
- account/users
summary: Deletes a user from your account.
description: >
Deletes a user. The deleted user will be immediately logged out and
may no longer log in or perform any actions. All grants that user had
will be lost.
operationId: deleteUser
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: User deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/account/users/{username}/grants:
parameters:
- name: username
in: path
description: The username to look up.
required: true
schema:
type: string
get:
x-linode-grant: unrestricted only
tags:
- account/users
summary: View grants for a user.
description: >
Returns the full grants structure for this user. This includes all
entities on the account alongside what level of access this user has
to each of them. Individual users may view their own grants at the
`/profile/grants` endpoint, but will not see entities that they have
no access to.
operationId: getUserGrants
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: The user's grants.
content:
application/json:
schema:
$ref: '#/components/schemas/GrantsResponse'
'204':
description: >
This is an unrestricted user, and therefore has no grants to return.
This user may access everything on the account and perform all actions.
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: unrestricted only
tags:
- account/users
summary: Update a user's grants.
description: >
Update the grants a user has. This can be used to give a user access
to new entities or actions, or take access away. You do not need to
include the grant for every entity on the account in this request; any
that are not included will remain unchanged.
operationId: updateUserGrants
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The grants to update. Omitted grants will be left unchanged.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/GrantsResponse'
responses:
'200':
description: Grants updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/GrantsResponse'
default:
$ref: '#/components/responses/ErrorResponse'
/account/transfer:
get:
x-linode-grant: read_only
tags:
- account
summary: View your network utilization for the current month, in Gigabytes.
description: >
This endpoint returns a Transfer object.
operationId: getTransfer
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a Transfer object.
content:
application/json:
schema:
$ref: '#/components/schemas/Transfer'
default:
$ref: '#/components/responses/ErrorResponse'
/domains:
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- domains
summary: View your domains in Linode's DNS Manager.
description: >
This is a collection of domains that you have registered in Linode's DNS
Manager. Linode is not a registrar, and in order for these to work you
must own the domains and point your registrar at Linode's nameservers.
operationId: getDomains
security:
- personalAccessToken: []
- oauth:
- domains:read_only
responses:
'200':
description: |
A paginated list of Domains you have registered.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Domain'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: add_domains
tags:
- domains
summary: Manage a new domain with Linode's DNS Manager.
description: >
Adds a new domain to Linode's DNS Manager. Linode is not a registrar, and
you must own the domain before adding it here. Be sure to point your
registrar to Linode's nameservers so that the records hosted here are
used.
operationId: createDomain
security:
- personalAccessToken: []
- oauth:
- domains:read_write
requestBody:
description: Information about the domain you are registering.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Domain'
responses:
'200':
description: |
Domain added successfully.
content:
applicaton/json:
schema:
$ref: '#/components/schemas/Domain'
default:
$ref: '#/components/responses/ErrorResponse'
/domains/{domainId}:
parameters:
- name: domainId
in: path
description: The ID of the Domain to access.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- domains
summary: View a single domain in Linode's DNS Manager.
description: >
This is a single domain that you have registered in Linode's DNS Manager.
Linode is not a registrar, and in order for this domain record to work you
must own the domain and point your registrar at Linode's nameservers.
operationId: getDomain
security:
- personalAccessToken: []
- oauth:
- domains:read_only
responses:
'200':
description: |
A single domain in Linode's DNS Manager.
content:
application/json:
schema:
$ref: '#/components/schemas/Domain'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- domains
summary: Update a Domain zone
description: |
Update information about a domain in Linode's DNS Manager.
operationId: updateDomain
security:
- personalAccessToken: []
- oauth:
- domains:read_write
requestBody:
description: The Domain information to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Domain'
responses:
'200':
description: Domain update successful.
content:
application/json:
schema:
$ref: '#/components/schemas/Domain'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- domains
summary: Delete a domain from Linode's DNS Manager.
description: >
Deletes a domain from Linode's DNS Manager. The domain will be removed
from Linode's nameservers shortly after this operation completes. This
also deletes all associated Domain Records.
operationId: deleteDomain
security:
- personalAccessToken: []
- oauth:
- domains:read_write
responses:
'200':
description: Domain deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/images:
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- images
summary: Returns a paginated list of public and private Images.
description: >
Returns a paginated list of Images. This list includes public Images and
your private Images. You can call this enpoint without authentication
to get all of the public Images.
operationId: getImages
security:
- personalAccessToken: []
- oauth:
- images:read_only
responses:
'200':
description: A paginated list of Images.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/ImagePublic'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- images
summary: >
Creates a private gold-master Image from a Disk.
description: >
Creates a new private gold-master Image from a Linode Disk. There is no
additional charge to store Images for Linode users, with a limit of 2GB
per Image and 3 Images per account.
operationId: createImage
security:
- personalAccessToken: []
- oauth:
- images:read_write
requestBody:
description: Information about the Image to create.
content:
application/json:
schema:
required:
- disk_id
type: object
allOf:
- $ref: '#/components/schemas/ImagePrivate'
- properties:
disk_id:
type: integer
format: int32
description: >
The ID of the Linode Disk that this Image will be
created from.
example: 42
label:
type: string
description: >
A short title of the Image. Defaults to the label of the
Disk it is being created from if not provided.
description:
type: string
description: >
A detailed description of the Image.
responses:
'200':
description: New private Image created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/ImagePrivate'
default:
$ref: '#/components/responses/ErrorResponse'
/images/{imageId}:
parameters:
- name: imageId
in: path
description: ID of the gold-master image to look up.
required: true
schema:
type: string
get:
tags:
- images
summary: Information about a specific gold-master Image.
description: >
Get information about a single image.
operationId: getImage
responses:
'200':
description: A single image object.
content:
application/json:
schema:
$ref: '#/components/schemas/ImagePrivate'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- images
summary: Update a private Image.
description: >
This allows you to update an private Image that you have permission to
`read_write`.
operationId: updateImage
security:
- personalAccessToken: []
- oauth:
- images:read_write
requestBody:
description: >
Any field that is not marked as `readOnly` may not be updated. If any
updated field fails to pass validation, the image will not be updated.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/ImagePrivate'
responses:
'200':
description: The updated image.
content:
application/json:
schema:
$ref: '#/components/schemas/ImagePrivate'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- images
summary: Delete a private Image.
description: |
Deletes an Image you have permission to `read_write`. Deleting an image is a destructive
process and cannot be undone. Only private Images are deletable.
operationId: deleteImage
security:
- personalAccessToken: []
- oauth:
- images:read_write
responses:
'200':
description: Delete successful
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances:
summary: A collection of your Linodes.
description: >
A collection of Linodes you have access to. Through this collection you can create servers and
view servers active on your account.
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
summary: Lists your Linodes.
description: >
Returns a paginated list of Linodes you have permission to view.
tags:
- linode/instances
operationId: getLinodeInstaces
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: Returns a list of all Linodes on your account.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Linode'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-charge: true
x-linode-grant: add_linodes
summary: Create a new Linode.
description: |
This endpoint allows you to create a new Linode server 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. See `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, see `GET /regions` for a list
of available regions you deploy your Linode in.
Linodes can be created in a number of ways:
- Using a Linode Linux Distribution image or an image you created based on another Linode
- The Linode will be `running` after it completes `provisioning`
- A default a 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 `password` 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
- Using one of your own StackScripts or a public StackScript
- The Linode will be `running` after it completes `provisioning`
- Requires a compatible Linode Linux Distribution `image` to be supplied
- see `GET /linode/stackscript/{stackscriptId}` 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
- Using one of your other Linode's backups
- The Linode will be `running` after it completes `provisioning`
- 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
- Create an empty Linode
- The Linode will remain `offline` and must be manually started
- see `POST /linode/instances/{linodeId}/boot`
- Disks and Configs must be created manually
- This is only recommended for advanced use-cases
tags:
- linode/instances
operationId: createLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The requested initial state of a new Linode.
required: true
content:
application/json:
schema:
type: object
required:
- type
- region
allOf:
- $ref: '#/components/schemas/LinodeRequest'
- $ref: '#/components/schemas/LinodeBase'
properties:
backup_id:
type: integer
title: The ID of a Linode Backup
example: 1234
description: |
A Backup ID from another Linode's available backups. Your user must have
`read_write` access to that Linode, the backup must have a `status` of
`successful`, and the Linode must be deployed to the same `region` as the backup.
See `GET /linode/instances/{linodeId}/backups` for a Linode's available backups.
This field and the `image` field are mutually exclusive.
backups_enabled:
type: boolean
title: If Backups should be enabled.
description: |
If this field is set to `true`, the created Linode will automatically be
enrolled in the Linode Backup service. This will incur an additional charge.
The cost for the Backup service is dependent on the type of Linode deployed.
Backup pricing is included in the response from `GET /linodes/types`
swap_size:
type: integer
title: Swap Disk size in MB
example: 512
description: >
When deploying from an Image, this field is optional, otherwise it is ignored.
This is used to set the Swap Disk size for the newly created Linode.
default: 512
responses:
'200':
description: >
A new Linode is being created.
content:
application/json:
schema:
$ref: '#/components/schemas/Linode'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up
required: true
schema:
type: integer
get:
x-linode-grant: read_only
tags:
- linode/instances
summary: Get a specific Linode
description: Get a specific Linode by ID.
operationId: getLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: Returns a single Linode object.
content:
application/json:
schema:
$ref: '#/components/schemas/Linode'
links:
boot:
$ref: '#/components/links/bootLinode'
reboot:
$ref: '#/components/links/rebootLinode'
shutdown:
$ref: '#/components/links/shutdownLinode'
update:
$ref: '#/components/links/updateLinode'
delete:
$ref: '#/components/links/deleteLinode'
rebuild:
$ref: '#/components/links/rebuildLinode'
mutate:
$ref: '#/components/links/mutateLinode'
resize:
$ref: '#/components/links/resizeLinode'
rescue:
$ref: '#/components/links/rescueLinode'
clone:
$ref: '#/components/links/cloneLinode'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- linode/instances
summary: Update a Linode
description: >
This allows you to update a Linode that you have permission to `read_write`.
operationId: updateLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: >
Any field that is not marked as `readOnly` may be updated. Fields that are marked
`readOnly` will be ignored. If any updated field fails to pass validation, the Linode will
not be updated.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Linode'
responses:
'200':
description: The updated Linode.
content:
application/json:
schema:
$ref: '#/components/schemas/Linode'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- linode/instances
summary: Delete a Linode.
description: |
Deletes a Linode you have permission to `read_write`. Deleting a Linode is a destructive
process and cannot be undone. Additionally, deleting a Linode:
* Gives up any IP addresses the Linode was assigned
* Deletes all disks, backups, configs, etc.
* Stops billing for the Linode and its associated services. You will be billed for time used
within the billing period the Linode was active.
operationId: deleteLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: Delete successful
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/backups:
parameters:
- name: linodeId
in: path
description: The ID of the Linode the backups belong to.
required: true
schema:
type: integer
get:
x-linode-grant: read_only
summary: Returns information about this Linode's available backups.
description: >
Returns information about this Linode's available backups.
tags:
- linode/instances
operationId: getBackups
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: A collection of the specified Linode's available backups.
content:
application/json:
schema:
type: object
properties:
automatic:
type: array
items:
allOf:
- $ref: '#/components/schemas/Backup'
- type: object
properties:
type:
type: string
example: automatic
snapshot:
type: object
properties:
in_progress:
$ref: '#/components/schemas/Backup'
current:
$ref: '#/components/schemas/Backup'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
summary: Takes a manual snapshot of the specified Linode.
description: >
Creates a snapshot backup of a Linode. WARNING: If you already have a
snapshot this is a destructive operation. The previous snapshot will be
deleted.
tags:
- linode/instances
operationId: createSnapshot
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The label for the new snapshot.
required: true
content:
application/json:
schema:
required:
- label
type: object
properties:
label:
type: string
minLength: 1
maxLength: 255
example: SnapshotLabel
responses:
'200':
description: Snapshot was successfully taken.
content:
application/json:
schema:
$ref: '#/components/schemas/Backup'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/backups/cancel:
parameters:
- name: linodeId
in: path
description: The ID of the Linode to cancel backup service for.
required: true
schema:
type: integer
post:
x-linode-grant: read_write
summary: Cancel backup service for a Linode.
description: >
Cancels the backup service on the given Linode.
tags:
- linode/instances
operationId: cancelBackups
security:
- personalAccessToken: []
- oauth:
- linode:read_write
responses:
'200':
description: Backup service was cancelled for the specified Linode.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/backups/enable:
parameters:
- name: linodeId
in: path
description: The ID of the Linode to enable backup service for.
required: true
schema:
type: integer
post:
x-linode-grant: read_write
summary: Enables backups for the specified Linode.
description: >
Enables backups for the specified Linode.
tags:
- linode/instances
operationId: enableBackups
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: Backup service was enabled.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/backups/{backupId}:
parameters:
- name: linodeId
in: path
description: The ID of the Linode the backup belongs to.
required: true
schema:
type: integer
- name: backupId
in: path
description: The ID of the backup to look up.
required: true
schema:
type: integer
get:
x-linode-grant: read_only
summary: Return information about a backup.
description: >
Return information about a backup.
tags:
- linode/instances
operationId: getBackup
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: A single Linode backup.
content:
application/json:
schema:
$ref: '#/components/schemas/Backup'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/backups/{backupId}/restore:
parameters:
- name: linodeId
in: path
description: The ID of the Linode that the backup belongs to.
required: true
schema:
type: integer
- name: backupId
in: path
description: The ID of the backup to restore.
required: true
schema:
type: integer
post:
x-linode-grant: read_write
summary: Restores a Linode's backup to the specified Linode.
description: >
Restores a Linode's backup to the specified Linode.
tags:
- linode/instances
operationId: restoreBackup
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: Parameters to provide when restoring the backup.
required: true
content:
application/json:
schema:
type: object
required:
- linode_id
properties:
linode_id:
type: integer
format: int32
description: >
The ID of the Linode to restore a backup to.
example: 123456
overwrite:
type: boolean
description: >
If true, deletes all disks and configs on the target linode
before restoring.
example: true
responses:
'200':
description: Restore from backup was initiated.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/boot:
parameters:
- name: linodeId
in: path
description: The ID of the Linode to boot
required: true
schema:
type: integer
post:
x-linode-grant: read_write
summary: Boot a Linode.
description: |
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.
tags:
- linode/instances
operationId: bootLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: Optional configuration to boot into (see above).
required: false
content:
application/json:
schema:
type: object
properties:
config_id:
type: integer
format: int32
description: >
The Linode Config ID to boot into. If omitted, we will attempt to select a
config to use (this will do the right thing in most cases).
example: null
responses:
'200':
description: Boot started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/reboot:
parameters:
- name: linodeId
in: path
description: ID of the linode to reboot.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
summary: Reboot a Linode.
description: >
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.
tags:
- linode/instances
operationId: rebootLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: Reboot started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/shutdown:
parameters:
- name: linodeId
in: path
description: ID of the Linode to shutdown.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
summary: Shuts down a Linode.
description: >
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.
tags:
- linode/instances
operationId: shutdownLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: Shutdown started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/mutate:
parameters:
- name: linodeId
in: path
description: ID of the Linode to mutate.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
summary: Upgrades a Linode to its next generation.
description: >
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.
tags:
- linode/instances
operationId: mutateLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: Mutate started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/resize:
parameters:
- name: linodeId
in: path
description: ID of the Linode to resize.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
summary: Resizes a Linode.
description: >
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:
* Any pending free upgrades to the Linode's current type must be performed
before a resize can occur.
* 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.
tags:
- linode/instances
operationId: resizeLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The type your current Linode will resize to.
required: true
content:
application/json:
schema:
type: object
required:
- type
properties:
type:
$ref: '#/components/schemas/LinodeBase/properties/type'
responses:
'200':
description: Resize started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/rebuild:
parameters:
- name: linodeId
in: path
description: ID of the Linode to rebuild.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
summary: Rebuilds a Linode.
description: >
This endpoint allows you to rebuild a Linode if you have the `read_write`
permission for it. If any actions are currently running or queued,
those actions must be completed first before you can initiate a rebuild.
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.
tags:
- linode/instances
operationId: rebuildLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The requested state your Linode will be rebuilt into.
required: true
content:
application/json:
schema:
type: object
required:
- image
- root_pass
allOf:
- $ref: '#/components/schemas/LinodeRequest'
properties:
image:
type: string
root_pass:
type: string
responses:
'200':
description: Rebuild started.
content:
application/json:
schema:
$ref: '#/components/schemas/Linode'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/rescue:
parameters:
- name: linodeId
in: path
description: ID of the Linode to rescue.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
summary: Boots a Linode into Rescue Mode.
description: >
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.
tags:
- linode/instances
operationId: rescueLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: Optional object of devices to be mounted.
required: false
content:
application/json:
schema:
type: object
properties:
devices:
$ref: '#/components/schemas/RescueDevices'
responses:
'200':
description: Rescue started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/clone:
parameters:
- name: linodeId
in: path
description: ID of the Linode to clone.
required: true
schema:
type: integer
format: int32
post:
x-linode-charge: true
x-linode-grant: add_linodes
summary: Clones a Linode to a new or existing Linode.
description: >
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.
tags:
- linode/instances
operationId: cloneLinodeInstance
security:
- personalAccessToken: []
- oauth:
- linodes:create
requestBody:
description: The requested state your Linode will be cloned into.
required: true
content:
application/json:
schema:
type: object
properties:
region:
type: string
title: The Region a Linode is deploy to.
description: >
This is the location where the Linode will be deployed.
To view all available regions you can deploy with see
`GET /regions`.
* Region can only be provided when cloning to a new Linode.
type:
type: string
title: The Linode service plan type.
description: |
A Linode's type determines what resources are available to
it, including disk space, memory, and virtual cpus. The
amounts available to a specific Linode are returned as
`specs` on the Linode object.
To view all available Linode `types` you can deploy with
see `GET /linode/types`.
* Type can only be provided wen cloning to a new Linode.
linode_id:
type: integer
title: Target clone's Linode ID.
description: >
If an existing Linode is to be the target for the clone,
the ID of that Linode.
label:
type: string
title: Label for the target Linode.
description: >
The label to assign this Linode when cloning to a new Linode.
* Can only be provided when cloning to a new Linode.
* Defaults to "linode".
group:
type: string
title: The group this Linode is in.
description: >
A label used to group Linodes for display. Linodes are not
required to have a group.
backups_enabled:
type: boolean
title: If Backups should be enabled.
description: |
If this field is set to `true`, the created Linode will
automatically be enrolled in the Linode Backup service. This
will incur an additional charge. The cost for the Backup
service is dependent on the type of Linode deployed.
Backup pricing is included in the response from
`GET /linodes/types`.
* Can only be included when cloning to a new Linode.
disks:
type: array
title: List of disk IDs to include.
description: >
All disks attached to configs will be cloned from the
source Linode if not provided.
configs:
type: array
title: List of config IDs to include.
description: >
All configs attached to will be cloned from the source
Linode if not provided.
responses:
'200':
description: Clone started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/ips:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- linode/instances
summary: Returns networking information for a Linode.
description: >
Returns networking information for a single Linode.
operationId: getLinodeIPs
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: Requested Linode's networking configuration.
content:
application/json:
schema:
type: object
properties:
ipv4:
type: object
description: >
Information about this Linode's IPv4 addresses
readOnly: true
properties:
public:
type: array
items:
$ref: '#/components/schemas/IPAddress'
description: >
A list of public IP Address objects belonging to this Linode.
readOnly: true
private:
type: array
items:
$ref: '#/components/schemas/IPAddress'
description: >
A list of private IP Address objects belonging to this Linode.
readOnly: true
shared:
type: array
items:
$ref: '#/components/schemas/IPAddress'
description: >
A list of IP Address objects that are shared with this Linode
(this Linode may bring up the address, but does not own it).
readOnly: true
ipv6:
type: object
description: >
Information about this Linode's IPv6 addresses.
readOnly: true
properties:
link_local:
$ref: '#/components/schemas/IPAddress'
slaac:
$ref: '#/components/schemas/IPAddress'
global:
type: array
items:
type: string
description: >
A list of global pools or ranges this Linode may bring up.
readOnly: true
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- linode/instances
summary: Allocate a public or private IPv4 address to a Linode.
description: >
Allocate a public or private IPv4 address to a Linode.
Public IP Addresses, over and above 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 ticket.
One may not add more than one private IPv4 address to a single Linode.
operationId: addLinodeIP
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: IP address was successfully allocated.
content:
application/json:
schema:
$ref: '#/components/schemas/IPAddress'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/ips/{address}:
parameters:
- name: linodeId
in: path
description: The ID of the Linode to look up.
required: true
schema:
type: integer
format: int32
- name: address
in: path
description: The IP address to look up.
required: true
schema:
type: string
format: ip
get:
x-linode-grant: read_only
tags:
- linode/instances
summary: View information about the specified IP address.
description: >
View information about the specified IP address associated
with the specified Linode.
operationId: getLinodeIP
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: A single IP address.
content:
application/json:
schema:
$ref: '#/components/schemas/IPAddress'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- linode/instances
summary: Manage a particular IP Address associated with this Linode.
description: >
Manage a particular IP Address associated with this Linode.
Currently only allows setting/resetting reverse DNS.
operationId: updateLinodeIP
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The information to update for the IP address.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/IPAddress'
- properties:
rdns:
type: string
example: linode.com
responses:
'200':
description: The updated IP address record.
content:
application/json:
schema:
$ref: '#/components/schemas/IPAddress'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- linode/instances
summary: Remove a particular public IPv4 address from this Linode.
description: >
Delete a public IPv4 address associated with this Linode. This will
fail if it is the Linode's last remaining IP address. Private
IPv4 addresses cannot be removed via this endpoint.
operationId: removeLinodeIP
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: IP address successfully removed.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/volumes:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- linode/instances
summary: Information about Volumes attached to this Linode.
description: >
View Block Storage Volumes attached to this Linode.
operationId: getLinodeVolumes
security:
- personalAccessToken: []
- oauth:
- linodes:read
responses:
'200':
description: >
Returns an array of Block Storage Volumes attached to this Linode.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Volume'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/configs:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up configuration profiles for.
required: true
schema:
type: integer
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- linode/instances
summary: Lists configuration profiles associated with a Linode.
description: |
Lists configuration profiles associated with a Linode.
operationId: getLinodeConfigs
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: >
Returns an array of configuration profiles associated with this Linode.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/LinodeConfig'
post:
tags:
- linode/instances
summary: Adds a new configuration profile to a Linode.
description: >
Adds a new configuration profile to a Linode.
operationId: addLinodeConfig
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: >
The parameters to set when creating the configuration profile.
This determines which kernel, devices, how much memory, etc. a Linode boots with.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeConfig'
responses:
'200':
description: |
A configuration profile was created.
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeConfig'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/configs/{configId}:
parameters:
- name: linodeId
in: path
description: The ID of the Linode whose configuration profile to look up.
required: true
schema:
type: integer
format: int32
- name: configId
in: path
description: The ID of the configuration profile to look up.
required: true
schema:
type: integer
format: int32
get:
tags:
- linode/instances
x-linode-grant: read_only
summary: Returns information about a specific configuration profile.
description: >
Returns information about a specific configuration profile.
operationId: getLinodeConfig
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: A configuration profile object.
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeConfig'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
summary: Update a configuration profile.
description: >
Updates the parameters of a single configuration profile.
tags:
- linode/instances
operationId: updateLinodeConfig
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The configuration profile parameters to modify.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeConfig'
responses:
'200':
description: Configuration profile successfully updated.
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeConfig'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
summary: Delete a configuration profile.
description: >
Deletes the specified configuration profile from the specified Linode.
x-linode-grant: read_write
tags:
- linode/instances
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: >
Configuration profile successfully deleted.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/disks:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- linode/instances
summary: Information about Disks associated with this Linode.
description: >
View Disk information for disks associated with this Linode.
operationId: getLinodeDisks
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: Returns a paginated list of disks associated with this Linode.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Disk'
default:
$ref: '#/components/responses/ErrorResponse'
post:
tags:
- linode/instances
summary: Adds a new disk to a Linode.
description: >
Adds a new disk to a Linode. You can optionally create a disk
from an image (see `GET /images` for a list of available public images,
or use one of your own), and optionally provide a StackScript to deploy
with this Disk.
operationId: addLinodeDisk
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: >
The parameters to set when creating the disk.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/DiskRequest'
responses:
'200':
description: Disk created.
content:
application/json:
schema:
$ref: '#/components/schemas/Disk'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/disks/{diskId}:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
format: int32
- name: diskId
in: path
description: ID of the Disk to look up.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- linode/instances
summary: Information about a single Disk associated with this Linode.
description: >
View Disk information for a disk associated with this Linode.
operationId: getLinodeDisk
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: Returns a single Disk object.
content:
application/json:
schema:
$ref: '#/components/schemas/Disk'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- linode/instances
summary: Update a Disk
description: >
This allows you to update a Disk that you have permission to `read_write`.
operationId: updateDisk
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: >
Updates the parameters of a single Disk.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Disk'
responses:
'200':
description: The updated Disk.
content:
application/json:
schema:
$ref: '#/components/schemas/Disk'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- linode/instances
summary: Delete a Disk.
description: |
Deletes a Disk you have permission to `read_write`. Deleting a Disk is a
destructive process and cannot be undone.
operationId: deleteDisk
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
responses:
'200':
description: Delete successful
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/disks/{diskId}/password:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
format: int32
- name: diskId
in: path
description: ID of the Disk to look up.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
tags:
- linode/instances
summary: Reset the root password of a disk.
description: >
This endpoint allows you to reset the password of a disk you have
permission to `read_write`.
operationId: resetDiskPassword
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The new password.
required: true
content:
application/json:
schema:
type: object
required:
- password
properties:
password:
type: string
title: The root password for the Disk.
description: >
The new root password for the OS installed on this Disk.
The password must contain at least two of these four
character classes:
* lowercase letters
* uppercase letters
* numbers
* punctuation
minLength: 6
maxLength: 128
example: another@complex^Password123
format: password
responses:
'200':
description: Returns a single Disk object.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/disks/{diskId}/resize:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
format: int32
- name: diskId
in: path
description: ID of the Disk to look up.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
tags:
- linode/instances
summary: Resizes the disk.
description: >
This endpoint allows you to resize a disk you have
permission to `read_write`.
The Linode this Disk is attached to must be shut down for resizing to
take effect.
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.
operationId: resizeDisk
security:
- personalAccessToken: []
- oauth:
- linodes:read_write
requestBody:
description: The new size of the Disk.
required: true
content:
application/json:
schema:
type: object
properties:
size:
type: string
title: The requested size of the Disk.
description: >
The desired size of the disk, in MB.
The Linode this Disk is attached to must be shut down for
resizing to take effect.
minimum: 1
example: 2048
responses:
'200':
description: Returns a single Disk object.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/stats:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
get:
tags:
- linode/instances
summary: Returns statistics for your Linode.
description: >
This endpoint returns CPU, IO, IPv4, and IPv6 statistics for your Linode
for the past 24 hours.
operationId: getLinodeStats
security:
- personalAccessToken: []
- oauth:
- linodes:read_only
responses:
'200':
description: The Linode's stats for the past 24 hours.
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeStats'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/instances/{linodeId}/stats/{year}/{month}:
parameters:
- name: linodeId
in: path
description: ID of the Linode to look up.
required: true
schema:
type: integer
format: int32
- name: year
in: path
description: Numeric value representing the year to look up.
required: true
schema:
type: integer
format: int32
- name: month
in: path
description: Numeric value representing the month to look up.
required: true
schema:
type: integer
format: int32
minimum: 1
maximum: 12
get:
tags:
- linode/instances
summary: Returns statistics for a specific year/month period.
description: >
This endpoint 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.
operationId: getLinodeStatsByYearMonth
security:
- personalAccessToken: []
- oauth:
- linodes_read_only
responses:
'200':
description: The Linode's statistics for the requested period.
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeStats'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/kernels:
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- linode/kernels
summary: Lists available kernels.
description: |
Lists available kernels.
operationId: getKernels
responses:
'200':
description: Returns a list of kernels.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Kernel'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/kernels/{kernelId}:
parameters:
- name: kernelId
in: path
description: ID of the kernel to look up.
required: true
schema:
type: string
get:
tags:
- linode/kernels
summary: Returns information about a specific kernel.
description: >
Get information about a single kernel.
operationId: getKernel
responses:
'200':
description: A single Kernel object.
content:
application/json:
schema:
$ref: '#/components/schemas/Kernel'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/stackscripts:
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- linode/stackscripts
summary: >
Returns a list of publicly available StackScripts. If the request is
authenticated, the list also includes private StackScripts the user has
permissions to view.
description: >
Returns a list of publicly available StackScripts. If the request is
authenticated, the list also includes private StackScripts the user has
permissions to view.
operationId: getStackScripts
security:
- personalAccessToken: []
- oauth:
- stackscripts:read_only
responses:
'200':
description: >
A list of publicly available StackScripts, including private
StackScripts owned by the user if the request is authenticated.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/StackScript'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: add_stackscripts
tags:
- linode/stackscripts
summary: Add a new StackScript to your account.
description: >
This endpoint allows you to add a new StackScript to your account.
operationId: addStackScript
security:
- personalAccessToken: []
- oauth:
- stackscripts:read_write
requestBody:
description: The properties to set for the new StackScript.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/StackScript'
responses:
'200':
description: StackScript successfully created.
content:
application/json:
schema:
$ref: '#/components/schemas/StackScript'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/stackscripts/{stackscriptId}:
parameters:
- name: stackscriptId
in: path
description: The ID of the StackScript to look up.
required: true
schema:
type: string
get:
x-linode-grant: read_only
tags:
- linode/stackscripts
summary: Returns information about a specific StackScript.
description: >
This endpoint returns all of the information about a specified
StackScript, including the contents of the script.
operationId: getStackScript
security:
- personalAccessToken: []
- oauth:
- stackscripts:read_only
responses:
'200':
description: A single StackScript.
content:
application/json:
schema:
$ref: '#/components/schemas/StackScript'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- linode/stackscripts
summary: Modifies the properties of a specific StackScript.
description: >
This endpoint allows you to modify a StackScript. Setting a
StackScript to public is a permanent change.
operationId: updateStackScript
security:
- personalAccessToken: []
- oauth:
- stackscripts:read_write
responses:
'200':
description: StackScript was successfully modified.
content:
application/json:
schema:
$ref: '#/components/schemas/StackScript'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- linode/stackscripts
summary: Deletes a StackScript.
description: >
This endpoint allows you to permanently delete a specific StackScript.
You cannot delete a public StackScript.
operationId: deleteStackScript
security:
- personalAccessToken: []
- oauth:
- stackscripts:read_write
responses:
'200':
description: StackScript was deleted.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/linode/types:
get:
tags:
- linode/types
summary: Returns collection of Linode types.
description: >
Returns collection of Linode types, including pricing and
specifications for each type. These are used when creating or resizing
Linodes.
operationId: getLinodeTypes
responses:
'200':
description: A collection of Linode types.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/LinodeType'
default:
$ref: '#/components/responses/ErrorResponse'
/linode/types/{typeId}:
parameters:
- name: typeId
in: path
description: The ID of the Linode type to look up.
required: true
schema:
type: string
get:
tags:
- linode/types
summary: Returns information about the specified Linode type.
description: >
Returns information about a specific Linode type, including pricing and
specifications. This is used when creating or resizing a Linode.
operationId: getLinodeType
responses:
'200':
description: A single Linode type.
content:
application/json:
schema:
$ref: '#/components/schemas/LinodeType'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/contacts:
get:
x-linode-grant: unrestricted only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- managed
summary: View your Managed Contacts.
description: >
Returns a paginated list of Managed Contacts on your account.
operationId: getManagedContacts
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A paginated list of ManagedContacts
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/ManagedContact'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: unrestricted only
tags:
- managed
summary: Create a new Managed Contact.
description: >
Creates a new Managed Contact. A Managed Contact is someone Linode
special forces can contact in the course of attempting to resolve an issue
with a Managed Service.
operationId: createManagedContact
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Information about the contact to create.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedContact'
responses:
'200':
description: Contact created.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedContact'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/contacts/{contactId}:
parameters:
- name: contactId
in: path
required: true
description: The ID of the contact to access.
schema:
type: integer
format: int32
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: View a single Managed Contact
description: >
Returns a single Managed Contact.
operationId: getManagedContact
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: The requested Managed Contact.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedContact'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: unrestricted only
tags:
- managed
summary: Update a Managed Contact
description: >
Updates information about a Managed Contact.
operationId: updateManagedContact
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedContact'
responses:
'200':
description: Contact updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedContact'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: unrestricted only
tags:
- managed
summary: Delete a Managed Contact
description: >
Deletes a Managed Contact.
operationId: deleteManagedContact
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Contact deleted successfully.
content:
application/json:
schema:
type: object
/managed/credentials:
get:
x-linode-grant: unrestricted only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- managed
summary: View your Managed Credentials.
description: >
Returns a paginated list of Managed Credentials on your account.
operationId: getManagedCredentials
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A paginated list of ManagedCredentials
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/ManagedCredential'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: unrestricted only
tags:
- managed
summary: Create a new Managed Credential.
description: >
Creates a new Managed Credential. A Managed Credential is stored securely
to allow Linode special forces to access your Managed Services and resolve
issues.
operationId: createManagedCredential
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Information about the credential to create.
content:
application/json:
schema:
type: object
required:
- label
allOf:
- $ref: '#/components/schemas/ManagedCredential'
- properties:
username:
type: string
minLength: 0
maxLength: 5000
description: >
The username to use when accessing the Managed Service.
example: johndoe
password:
type: string
minLength: 0
maxLength: 5000
description: >
The password to use when accessing the Managed Service.
example: s3cur3P@ssw0rd
format: password
responses:
'200':
description: Credential created.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedCredential'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/credentials/{credentialId}:
parameters:
- name: credentialId
in: path
required: true
description: The ID of the credential to access.
schema:
type: integer
format: int32
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: View a single Managed Credential
description: >
Returns a single Managed Credential.
operationId: getManagedCredential
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: The requested Managed Credential.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedCredential'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: unrestricted only
tags:
- managed
summary: Update a Managed Credential
description: >
Updates information about a Managed Credential.
operationId: updateManagedCredential
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedCredential'
responses:
'200':
description: Credential updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedCredential'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: unrestricted only
tags:
- managed
summary: Delete a Managed Credential
description: >
Deletes a Managed Credential. Linode special forces will no longer
have access to this credential when attempting to resolve issues.
operationId: deleteManagedCredential
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Credential deleted successfully.
content:
application/json:
schema:
type: object
/managed/issues:
get:
x-linode-grant: unrestricted only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- managed
summary: View recent and open issues related to your Managed Services.
description: >
Returns a paginated list of recent and ongoing issues detected on your
Managed Services.
operationId: getManagedIssues
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: >
A paginated list of open or ongoing Managed Issues.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/ManagedIssue'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/issues/{issueId}:
parameters:
- name: issueId
in: path
required: true
description: The issue to look up.
schema:
type: integer
format: int32
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: View a single issue related to one of your Managed Services.
description: >
Returns a single issue that is impacting or did impact one of your
Managed Services.
operationId: getManagedIssue
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: The requested issue.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedIssue'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/linode-settings:
get:
x-linode-grant: unrestricted only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- managed
summary: View Managed settings for your Linodes.
description: >
Returns a paginated list of Managed settings for your Linodes. There will
be one entry per Linode on your account.
operationId: getManagedLinodeSettings
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: >
A paginated list of Managed settings for your Linodes.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/ManagedLinodeSettings'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/linode-settings/{linodeId}:
parameters:
- name: linodeId
in: path
required: true
description: The Linode ID whose settings we are accessing.
schema:
type: integer
format: int32
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: View a single Linode's Managed settings.
description: >
Returns a single Linode's Managed settings.
operationId: getManagedLinodeSetting
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: The requested Linode's Managed settings.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedLinodeSettings'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: unrestricted only
tags:
- managed
summary: Update a single Linode's Managed settings.
description: >
Updates a single Linode's Managed settings.
operationId: updateManagedLinodeSetting
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The settings to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedLinodeSettings'
responses:
'200':
description: Settings updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedLinodeSettings'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/services:
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: View your Managed Services.
description: >
Returns a paginated list of Managed Services on your account. These
are the services Linode Managed is monitoring and will report and attempt
to resolve issues with.
operationId: getManagedServices
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A paginated list of Managed Services
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/ManagedService'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: unrestricted only
tags:
- managed
summary: Create a new Managed Service.
description: >
Creates a new Managed Service. Linode Managed will being monitoring this
service and reporting and attempting to resolve any issues.
operationId: createManagedService
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Information about the service to monitor.
content:
application/json:
schema:
type: object
required:
- label
allOf:
- $ref: '#/components/schemas/ManagedService'
responses:
'200':
description: Service created.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedService'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/services/{serviceId}:
parameters:
- name: serviceId
in: path
required: true
description: The ID of the Managed Service to access.
schema:
type: integer
format: int32
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: View a single Managed Service
description: >
Returns information about a single Managed Service on your account.
operationId: getManagedService
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: The requested Managed Service.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedService'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: unrestricted only
tags:
- managed
summary: Update a Managed Service
description: >
Updates information about a Managed Service.
operationId: updateManagedService
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedService'
responses:
'200':
description: Service updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedService'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: unrestricted only
tags:
- managed
summary: Delete a Managed Service
description: >
Deletes a Managed Service. This service will no longer be monitored by
Linode Managed.
operationId: deleteManagedService
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Service deleted successfully.
content:
application/json:
schema:
type: object
/managed/services/{serviceId}/disable:
parameters:
- name: serviceId
in: path
required: true
description: The ID of the Managed Service to disable.
schema:
type: integer
format: int32
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: Disables a Managed Service
description: >
Temporarily disables monitoring of a Managed Service.
operationId: disableManagedService
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Service disabled.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedService'
default:
$ref: '#/components/responses/ErrorResponse'
/managed/services/{serviceId}/enable:
parameters:
- name: serviceId
in: path
required: true
description: The ID of the Managed Service to enable.
schema:
type: integer
format: int32
get:
x-linode-grant: unrestricted only
tags:
- managed
summary: Enables a Managed Service
description: >
Re-enables monitoring of a Managed Service.
operationId: enableManagedService
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Service enabled.
content:
application/json:
schema:
$ref: '#/components/schemas/ManagedService'
default:
$ref: '#/components/responses/ErrorResponse'
/networking/ips:
description: >
A collection of IP Addresses on your account. Excludes private addresses.
get:
x-linode-grant: read_only
tags:
- networking
summary: Returns a list of your IP Addresses.
description: >
Returns a paginated list of IP Addresses on your account, excluding
private addresses.
operationId: getIPs
security:
- personalAccessToken: []
- oauth:
- ips:read_only
responses:
'200':
description: A paginated list of IP Addresses.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/IPAddress'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- networking
summary: Allocate a new IP Address.
description: >
Allocates a new IP Address on your account. Currently, only IPv4
addresses may be allocated this way. The Linode you are allocating
this address for must be allowed to allocate additional addresses -
please open a support ticket requesting additional addresses before
attempting allocation.
operationId: allocateIP
security:
- personalAccessToken: []
- oauth:
- ips:read_write
- linodes:read_write
requestBody:
description: Information about the address you are requesting.
required: true
content:
application/json:
schema:
type: object
required:
- type
- linode_id
properties:
type:
type: string
enum:
- ipv4
description: >
The type of address you are requesting. Right now, only
public ipv4 addresses may be allocated through this endpoint.
example: ipv4
linode_id:
type: integer
format: int32
description: >
The ID of a Linode you you have access to that this address
will be allocated to.
example: 123
responses:
'200':
description: IP Address allocated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/IPAddress'
default:
$ref: '#/components/responses/ErrorResponse'
/networking/ips/{address}:
parameters:
- name: address
in: path
required: true
description: The address to operate on.
schema:
type: string
format: ip
get:
x-linode-grant: read_only
tags:
- networking
summary: View a single IP Address
description: >
Returns information about a single IP Address on your account.
operationId: getIP
security:
- personalAccessToken: []
- oauth:
- ips:read_only
responses:
'200':
description: The requested IP Address.
content:
application/json:
schema:
$ref: '#/components/schemas/IPAddress'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- networking
summary: Set RDNS on an IP Address
description: >
Sets RDNS on an IP Address. Forward DNS must already be set up for
reverse DNS to be applied. If you set the RDNS to `null` for public
ipv4 addresses, it will be reset to the default members.linode.com
RDNS value.
operationId: updateIP
security:
- personalAccessToken: []
- oauth:
- ips:read_write
requestBody:
description: The information to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/IPAddress'
responses:
'200':
description: RDNS set successfully
content:
application/json:
schema:
$ref: '#/components/schemas/IPAddress'
default:
$ref: '#/components/responses/ErrorResponse'
/longview/clients:
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- longview
summary: Returns information about your Longview Clients.
description: >
Returns a paginated list of Longview Clients you have access
to. Longview Clients are used to monitor stats on your servers
with the help of the Longview Client application.
operationId: getLongviewClients
security:
- personalAccessToken: []
- oauth:
- longview:read_only
responses:
'200':
description: A paginated list of Longview Clients.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/LongviewClient'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: add_longview
tags:
- longview
summary: Create a new Longview Client.
description: >
Create a new Longview Client. This client will not begin monitoring
the status of one of your servers until you configure the Longview
Client application on your server using the returning `install_code`
and `api_key`.
operationId: createLongviewClient
security:
- personalAccessToken: []
- oauth:
- longview:read_write
requestBody:
description: Information about the LongviewClient to create.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/LongviewClient'
responses:
'200':
description: Longview Client created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/LongviewClient'
default:
$ref: '#/components/responses/ErrorResponse'
/longview/clients/{clientId}:
parameters:
- name: clientId
in: path
required: true
description: The Longview Client ID to access.
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- longview
summary: View a single Longview Client.
description: >
Returns a single Longview Client you can access.
operationId: getLongviewClient
security:
- personalAccessToken: []
- oauth:
- longview:read_only
responses:
'200':
description: The requested Longview Client.
content:
application/json:
schema:
$ref: '#/components/schemas/LongviewClient'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- longview
summary: Update information about a Longview Client.
description: >
Updates a Longview Client. This cannot update how it monitors your
server - use the Longview Client application on your server for
monitoring configuration.
operationId: updateLongviewClient
security:
- personalAccessToken: []
- oauth:
- longview:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/LongviewClient'
responses:
'200':
description: Longview Client updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/LongviewClient'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- longview
summary: Delete a Longview Client.
description: >
Deletes a Longview Client from your account. All information stored
for this client will be lost. This _does not_ uninstall the Longview
Client application for your server - you must do that manually.
operationId: deleteLongviewClient
security:
- personalAccessToken: []
- oauth:
- longview:read_write
responses:
'200':
description: Longview Client deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/longview/subscriptions:
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- longview
summary: Returns a list of available Longview Subscriptions.
description: >
Returns a paginated list of available Longview Subscriptions. This is
a public endpoint, and requires no authentication.
operationId: getLongviewSubscriptions
responses:
'200':
description: A paginated list of Longview Subscriptions.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/LongviewSubscription'
default:
$ref: '#/components/responses/ErrorResponse'
/longview/subscriptions/{subscriptionId}:
parameters:
- name: subscriptionId
in: path
required: true
description: The Longview Subscription to look up.
schema:
type: string
get:
tags:
- longview
summary: View a single Longview Subscription.
description: >
Returns a single LongviewSubscription object. This is a public
endpoint and requires no authentication.
operationId: getLongviewSubscription
responses:
'200':
description: The requested Longview Subscription.
content:
application/json:
schema:
$ref: '#/components/schemas/LongviewSubscription'
default:
$ref: '#/components/responses/ErrorResponse'
/networking/ipv4/assign:
description: >
Allows redistribution of v4 IP Addresses within a region. Any number
of IPs may be assigned in one request, as long as all Linodes end up
with at least one public and no more than one private IP Address at the
end of the assignment.
post:
x-linode-grant: read_write
tags:
- networking/ipv4
summary: Assign IPs to Linodes
description: >
Assign multiple IPs to multiple Linodes in one region. This allows
swapping, shuffling, or otherwise reorganizing v4 IP Addresses to your
Linodes. When the assignment is finished, all Linodes must end up with
at least one public ipv4 and no more than one private ipv4.
operationId: assignIPs
security:
- personalAccessToken: []
- oauth:
- ips:read_write
- linodes:read_write
requestBody:
description: >
Information about what ipv4 address to assign, and to which Linode.
required: true
content:
application/json:
schema:
type: object
required:
- region
- assignments
properties:
region:
type: string
description: >
The ID of the region in which these assignments are to take
place. All IPs and Linodes must exist in this region.
example: us-east
assignments:
type: array
description: >
The list of assignments to make. You must have read_write
access to all IPs being assigned and all Linodes being
assigned to in order for the assignments to succeed.
items:
type: object
properties:
address:
type: string
format: ip
description: >
Ths IP Address for this assignment. Must be a v4
address you can access in the region specified. May
be a public or private address.
example: 12.34.56.789
linode_id:
type: integer
format: int32
description: >
The ID of the Linode to assign this address to. The IP's
previous Linode will lose this address, and must end up
with at least one public address and no more than one
private address once all assignments have been made.
example: 123
responses:
'200':
description: All assignments completed successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/networking/ipv4/share:
description: >
Configure shared IPs. A shared IP may be brought up on a Linode other
than the one it lists in its response. This can be used to allow one
Linode to begin serving requests should another become unresponsive.
post:
x-linode-grant: read_write
tags:
- networking/ipv4
summary: Set up IP sharing.
description: >
Configure shared IPs. A shared IP may be brought up on a Linode other
than the one it lists in its response. This can be used to allow one
Linode to begin serving requests should another become unresponsive.
operationId: shareIPs
security:
- personalAccessToken: []
- oauth:
- ips:read_write
- linodes:read_write
requestBody:
description: Information about what IPs to share with which Linode.
required: true
content:
application/json:
schema:
type: object
required:
- linode_id
- ips
properties:
linode_id:
type: integer
format: int32
description: >
The ID of the Linode that the addresses will be shared with.
example: 123
ips:
type: array
items:
type: string
format: ip
example: 12.34.56.789
description: >
A list of IPs that will be shared with this Linode. When
this is finished, the given Linode will be able to bring up
these addresses in addition to the Linodes that these
addresses belong to. You must have access to all of these
addresses and they must be in the same region as the
Linode.
responses:
'200':
description: Sharing configured successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/networking/ipv6/pools:
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- networking/ipv6
summary: Returns the IPv6 pools on your account.
description: >
Displays the IPv6 pools on your account.
operationId: getIPv6Pools
security:
- personalAccessToken: []
- oauth:
- ips:read_only
responses:
'200':
description: The IPv6 pools on your account.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/IPv6Pool'
default:
$ref: '#/components/responses/ErrorResponse'
/networking/ipv6/ranges:
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- networking/ipv6
summary: Returns the IPv6 ranges on your account.
description: >
Displays the IPv6 ranges on your account.
operationId: getIPv6Ranges
security:
- personalAccessToken: []
- oauth:
- ips:read_only
responses:
'200':
description: The IPv6 ranges on your account.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/IPv6Range'
default:
$ref: '#/components/responses/ErrorResponse'
/nodebalancers:
get:
x-linode-grant: read_only
tags:
- nodebalancers
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
summary: List your NodeBalancers.
description: >
Returns a paginated list of NodeBalancers you have access to.
operationId: getNodeBalancers
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_only
responses:
'200':
description: A paginated list of NodeBalancers.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/NodeBalancer'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: add_nodebalancers
tags:
- nodebalancers
summary: Create a new NodeBalancer.
description: >
Creates a new NodeBalancer in the requested region. This NodeBalancer
will not start serving requests until it is configured.
operationId: createNodeBalancer
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
requestBody:
description: Information about the NodeBalancer to create.
required: true
content:
application/json:
schema:
type: object
required:
- region
properties:
region:
type: string
description: >
The ID of the region to create this NodeBalancer in.
example: us-east
label:
$ref: '#/components/schemas/NodeBalancer/properties/label'
client_conn_throttle:
$ref: '#/components/schemas/NodeBalancer/properties/client_conn_throttle'
responses:
'200':
description: NodeBalancer created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancer'
default:
$ref: '#/components/responses/ErrorResponse'
/nodebalancers/{nodeBalancerId}:
parameters:
- name: nodeBalancerId
in: path
description: The ID of the NodeBalancer to access.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- nodebalancers
summary: View a single NodeBalancer.
description: >
Returns a single NodeBalancer you can access.
operationId: getNodeBalancer
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_only
responses:
'200':
description: The requested NodeBalancer object.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancer'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Update information about a NodeBalancer
description: >
Update information about a NodeBalancer you can access.
operationId: updateNodeBalancer
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
requestBody:
description: The information to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancer'
responses:
'200':
description: NodeBalancer updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancer'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Delete a NodeBalancer.
description: >
Deletes a NodeBalancer. This cannot be undone. Deleting a
NodeBalancer will also delete all associated configs and nodes,
although the backend servers represented by the nodes will not
be changed or removed. Deleting a NodeBalancer will cause you
to lose access to the IP Addresses that NodeBalancer was
assigned.
operationId: deleteNodeBalancer
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
responses:
'200':
description: NodeBalancer deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/nodebalancers/{nodeBalancerId}/configs:
parameters:
- name: nodeBalancerId
in: path
description: The ID of the NodeBalancer to access.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- nodebalancers
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
summary: List configs for this NodeBalancer.
description: >
Returns a paginated list of NodeBalancerConfigs associated
with this NodeBalancer. NodeBalancer configs represent
individual ports that this NodeBalancer will accept traffic
on, one config per port. For example, if you wanted to
accept standard http traffic, you would need a config listening
on port 80.
operationId: getNodeBalancerConfigs
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_only
responses:
'200':
description: A paginted list of NodeBalancerConfigs
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/NodeBalancerConfig'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Configure a new port on this NodeBalancer.
description: >
Creates a new NodeBalancerConfig, which allows the NodeBalancer to
accept traffic on a new port. You will need to add NodeBalancerNodes
to the new config before it can actually serve requests.
operationId: createaNodeBalancerConfig
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
requestBody:
description: Information about the port to configure.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerConfig'
responses:
'200':
description: Config created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerConfig'
default:
$ref: '#/components/responses/ErrorResponse'
/nodebalancers/{nodeBalancerId}/configs/{configId}:
parameters:
- name: nodeBalancerId
in: path
description: The ID of the NodeBalancer to access.
required: true
schema:
type: integer
format: int32
- name: configId
in: path
description: The ID of the config to access.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- nodebalancers
summary: View a single NodeBalancer config.
description: >
Returns configuration information for a single port of this
NodeBalancer.
operationId: getNodeBalancerConfig
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_only
responses:
'200':
description: The requested NodeBalancer config.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerConfig'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Update a NodeBalancer config.
description: >
Update the configuration for a single port on a NodeBalancer.
operationId: updateNodeBalancerConfig
security:
- personlAccessToken: []
- oauth:
- nodebalancers:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerConfig'
responses:
'200':
description: Config updated successfully.
content:
applicaiton/json:
schema:
$ref: '#/components/schemas/NodeBalancerConfig'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Delete a NodeBalancer config.
description: >
Deletes the configuration for a port of this NodeBalancer. This
cannot be undone. Once completed, this NodeBalancer will no longer
respond to requests on the given port. This also deletes all
associated NodeBalancerNodes, but the Linodes they were routing
traffic to are unchanged and not removed.
operationId: deleteNodeBalancerConfig
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
responses:
'200':
description: NodeBalancerConfig deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes:
parameters:
- name: nodeBalancerId
in: path
description: The ID of the NodeBalancer to access.
required: true
schema:
type: integer
format: int32
- name: configId
in: path
description: The ID of the NodeBalancer config to access.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- nodebalancers
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
summary: List nodes for this config.
description: >
Returns a paginated list of NodeBalancer nodes associated with
this config. These are the backends that will be sent traffic
for this port.
operationId: getNodeBalancerConfigNodes
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_only
responses:
'200':
description: A paginated list of NodeBalancer nodes.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/NodeBalancerNode'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Create a new node on this config.
description: >
Creates a new NodeBalancer node, a backend that can accept
traffic, for this NodeBalancer config. Nodes are routed
requests on the configured port based on their status.
operationId: createNodeBalancerNode
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
requestBody:
description: Information about the node to create.
required: true
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/NodeBalancerNode'
required:
- label
- address
responses:
'200':
description: Node created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerNode'
default:
$ref: '#/components/responses/ErrorResponse'
/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes/{nodeId}:
parameters:
- name: nodeBalancerId
in: path
description: The ID of the NodeBalancer to access.
required: true
schema:
type: integer
format: int32
- name: configId
in: path
description: The ID of the Config to access
required: true
schema:
type: integer
format: int32
- name: nodeId
in: path
description: The ID of the Node to access
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- nodebalancers
summary: View a single NodeBalancer node.
description: >
Returns information about a single node, a backend for this
NodeBalancer's configured port.
operationId: getNodeBalancerNode
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
responses:
'200':
description: A paginated list of NodeBalancer nodes.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerNode'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Update a NodeBalancer node
description: >
Updates information about a node, a backend for this NodeBalancer's
configured port.
operationId: updateNodeBalancerNode
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerNode'
responses:
'200':
description: Node updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/NodeBalancerNode'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- nodebalancers
summary: Delete a NodeBalancer node
description: >
Deletes a node from this config. Is backend will no longer
receive traffic for the configured port of this NodeBalancer.
This does not change or remove the server whose address was
used in the creation of this node.
operationId: deleteNodeBalancerConfigNode
security:
- personalAccessToken: []
- oauth:
- nodebalancers:read_write
responses:
'200':
description: Node deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/regions:
get:
tags:
- regions
summary: List available regions for Linode services
description: |
Lists the regions available for Linode services. Not all services are guaranteed to be
available in all regions.
operationId: getRegions
responses:
'200':
description: Returns a list of Regions.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Region'
default:
$ref: '#/components/responses/ErrorResponse'
/regions/{regionId}:
parameters:
- name: regionId
in: path
description: ID of the Region to look up.
required: true
schema:
type: string
get:
tags:
- regions
summary: Information about a specific Region.
description: >
Get information about a single Region.
operationId: getRegion
responses:
'200':
description: A single Region object.
content:
application/json:
schema:
$ref: '#/components/schemas/Region'
default:
$ref: '#/components/responses/ErrorResponse'
/volumes:
summary: A collection of your Volumes.
description: >
A collection of Volumes you have access to. Through this collection you
can view Volumes active on your account, create new Volumes, resize an
existing Volume to a higher capacity, attach and detach a Volume to/from
a Linode, and clone an existing Volume.
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
summary: Lists your Volumes.
description: >
Returns a paginated list of Volumes you have permission to view.
tags:
- volumes
operationId: getVolumes
security:
- personalAccessToken: []
- oauth:
- volumes:read_only
responses:
'200':
description: Returns a list of all Volumes on your account.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/Volume'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-charge: true
x-linode-grant: add_volumes
summary: Create a new Volume.
description: >
This endpoint allows you to create a new Volume on your account. In order
for this to complete successfully, your user must have the `add_volumes`
grant. Creating a new Volume will start accruing additional charges
on your account.
Volume service may not be available in all regions. See `GET /regions`
for a list of available regions you deploy your Volume in.
tags:
- volumes
operationId: createVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_write
requestBody:
description: The requested initial state of a new Volume.
required: true
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/Volume'
- properties:
region:
$ref: '#/components/schemas/Region/properties/id'
responses:
'200':
description: >
Creating Volume.
content:
application/json:
schema:
$ref: '#/components/schemas/Volume'
/volumes/{volumeId}:
parameters:
- name: volumeId
in: path
description: ID of the Volume to look up.
required: true
schema:
type: integer
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- volumes
summary: Information about a specific Volume.
description: >
Get information about a single Volume.
operationId: getVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_only
responses:
'200':
description: Returns a single Volume object.
content:
application/json:
schema:
$ref: '#/components/schemas/Volume'
links:
attach:
$ref: '#/components/links/attachVolume'
clone:
$ref: '#/components/links/cloneVolume'
detach:
$ref: '#/components/links/detachVolume'
resize:
$ref: '#/components/links/resizeVolume'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- volumes
summary: Update a Volume
description: >
This allows you to update a Volume that you have permission to `read_write`.
operationId: updateVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_write
requestBody:
description: >
If any updated field fails to pass validation, the Volume will not be
updated.
required: true
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/Volume'
- properties:
region:
$ref: '#/components/schemas/Region/properties/id'
responses:
'200':
description: The updated Volume.
content:
application/json:
schema:
$ref: '#/components/schemas/Volume'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- volumes
summary: Delete a Volume.
description: |
Deletes a Volume you have permission to `read_write`. Deleting a Volume
is a destructive process and cannot be undone. Additionally, deleting
stops billing for the Volume. You will be billed for time used within
the billing period the Volume was active.
operationId: deleteVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_write
responses:
'200':
description: Volume deletion successful.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/volumes/{volumeId}/attach:
parameters:
- name: volumeId
in: path
description: ID of the Volume to attach.
required: true
schema:
type: integer
format: int32
post:
summary: Attaches a Volume to a Linode.
description: >
This endpoint allows you to attach a Volume on your account
to an existing Linode on your account. In order for this request to
complete successfully, your user must have `read_only` or `read_write`
permission to the Volume and `read_write` permission to the Linode.
Additionally, the Volume and Linode must be located in the same region.
tags:
- volumes
operationId: attachVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_write
- linodes:read_write
requestBody:
description: Volume to attach to a Linode.
required: true
content:
application/json:
schema:
type: object
required:
- linode
properties:
linode_id:
$ref: '#/components/schemas/Linode/properties/id'
config_id:
$ref: '#/components/schemas/LinodeConfig/properties/id'
responses:
'200':
description: Volume was attached to a Linode.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/volumes/{volumeId}/clone:
parameters:
- name: volumeId
in: path
description: ID of the Volume to clone.
required: true
schema:
type: integer
format: int32
post:
x-linode-charge: true
x-linode-grant: add_volumes
summary: Clones a Volume to a new Volume.
description: >
This endpoint allows you to create a new Volume on your account. In
order for this request to complete successfully, your user must have the
`add_volumes` grant. The new Volume will have the same size and data as
the source Volume. Creating a new Volume will incur a charge on your
account.
tags:
- volumes
operationId: cloneVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_write
requestBody:
description: The requested state your Volume will be cloned into.
required: true
content:
application/json:
schema:
type: object
required:
- label
properties:
label:
$ref: '#/components/schemas/Volume/properties/label'
responses:
'200':
description: Clone started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/volumes/{volumeId}/detach:
parameters:
- name: volumeId
in: path
description: ID of the Volume to detach.
required: true
schema:
type: integer
format: int32
post:
summary: Detaches a Volume from a Linode.
description: >
This endpoint allows you to detach a Volume on your account
from a Linode on your account. In order for this request to
complete successfully, your user must have `read_write` access to the
Volume and `read_write` access to the Linode.
tags:
- volumes
operationId: detachVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_write
- linodes:read_write
responses:
'200':
description: Volume was detached from a Linode.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/volumes/{volumeId}/resize:
parameters:
- name: volumeId
in: path
description: ID of the Volume to resize.
required: true
schema:
type: integer
format: int32
post:
x-linode-charge: true
summary: Clones a Volume to a new Volume.
description: >
This endpoint allows you to resize an existing Volume on your account. In
order for this request to complete successfully, your user must have the
`read_write` permissions to the Volume.
* Volumes can only be resized up.
tags:
- volumes
operationId: resizeVolume
security:
- personalAccessToken: []
- oauth:
- volumes:read_write
requestBody:
description: The requested size to increase your Volume to.
required: true
content:
application/json:
schema:
type: object
required:
- size
properties:
size:
$ref: '#/components/schemas/Volume/properties/size'
responses:
'200':
description: Volume resize started.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/domains/{domainId}/records:
parameters:
- name: domainId
in: path
description: The ID of the domain we are accessing records for.
required: true
schema:
type: integer
get:
x-linode-grant: read_only
tags:
- domains
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
security:
- personalAccessToken: []
- oauth:
- domains:read_only
summary: View domain records configured on a domain.
description: |
Returns a paginated list of records configured on a domain in Linode's
DNS Manager.
operationId: getDomainRecords
responses:
'200':
description: A list of domain records.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/DomainRecord'
post:
x-linode-grant: read_write
tags:
- domains
security:
- personalAccessToken: []
- oauth:
- domains:read_write
summary: Add a new record to this domain.
description: >
Adds a new domain record to the zonefile this domain represents.
requestBody:
description: >
Information about the new record to add.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/DomainRecord'
responses:
'200':
description: Domain record created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/DomainRecord'
default:
$ref: '#/components/responses/ErrorResponse'
/domains/{domainId}/records/{recordId}:
parameters:
- name: domainId
in: path
description: The ID of the domain whose record you are accessing.
required: true
schema:
type: integer
- name: recordId
in: path
description: The ID of the record you are accessing.
required: true
schema:
type: integer
get:
x-linode-grant: read_only
tags:
- domains
security:
- personalAccessToken: []
- oauth:
- domains:read_only
summary: View a single domain record.
description: |
View a single record on this domain.
responses:
'200':
description: A domain record object.
content:
application/json:
schema:
$ref: '#/components/schemas/DomainRecord'
default:
$ref: '#/components/responses/ErrorResponse'
put:
x-linode-grant: read_write
tags:
- domains
security:
- personalAccessToken: []
- oauth:
- domains:read_write
summary: Update a domain record.
description: |
Update a single record on this domain.
requestBody:
description: The values to change.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/DomainRecord'
responses:
'200':
description: Domain record updated.
content:
application/json:
schema:
$ref: '#/components/schemas/DomainRecord'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
x-linode-grant: read_write
tags:
- domains
security:
- personalAccessToken: []
- oauth:
- domains:read_write
summary: Delete a domain record.
description: |
Deletes a record on this domain.
responses:
'200':
description: Record deleted successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/profile:
get:
tags:
- profile
summary: Access your profile.
description: >
Returns information about the current user. This can be used to see
who is acting in applications where more than one token is managed, for
example in third-party OAuth applications. This endpoint is always
accessible, no matter what OAuth scopes the acting token has.
operationId: getProfile
security:
- personalAccessToken: []
- oauth: []
responses:
'200':
description: Profile response.
content:
application/json:
schema:
$ref: '#/components/schemas/Profile'
put:
tags:
- profile
summary: Update your profile.
description: >
Update information in your profile. This option is _not_ available to
all third-party clients.
operationId: updateProfile
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Profile'
responses:
'200':
description: Profile updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/Profile'
default:
$ref: '#/components/responses/ErrorResponse'
/profile/apps:
description: >
Returns information about OAuth Apps you have authorized to access your account.
get:
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- profile
summary: View apps that you've authorized to access your account.
description: >
This is a collection of OAuth apps that you've given access to your account, and
includes the level of access granted.
operationId: getProfileApps
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: |
A paginated list of apps you've authorized.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/AuthorizedApp'
default:
$ref: '#/components/responses/ErrorResponse'
/profile/apps/{appId}:
parameters:
- name: appId
in: path
required: true
description: The authorized app ID to manage.
schema:
type: integer
format: int32
get:
tags:
- profile
summary: View information about a single authorized app.
description: >
Returns information about a single app you've authorized to access your
account.
operationId: getProfileApp
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: The app requested.
content:
application/json:
schema:
$ref: '#/components/schemas/AuthorizedApp'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
tags:
- profile
summary: Revoke the access previously given to an app.
description: >
Expires all tokens and refresh tokens possessed by this app. This app is no
longer authorized to access your account.
operationId: deleteProfileApp
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: App's authorization has been revoked.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/profile/grants:
get:
tags:
- profile
summary: See what you have access to.
description: >
This returns a GrantsResponse describing what the acting user has been
granted access to. For unrestricted users, this will return a 204 and
no body because unrestricted users have access to everything without
grants. This will not return information about entities you do not have
access to. This endpoint is useful when writing third-party OAuth
applications to see what options you should present to the acting user
(for example, if they do not have `global.add_linodes`, you might not
display a button to deploy a new Linode). Any client may access this
endpoint, as no OAuth scopes are required.
operationId: getProfileGrants
security:
- personalAccessToken: []
- oauth: []
responses:
'200':
description: GrantsResponse
content:
application/json:
schema:
$ref: '#/components/schemas/GrantsResponse'
'204':
description: >
This is an unrestricted user, who has no grants. This user can access
everything on the account.
default:
$ref: '#/components/responses/ErrorResponse'
/profile/tfa-enable:
post:
tags:
- profile
summary: Generate a Two Factor secret, used to enable Two Factor Authentication.
description: >
Generates a Two Factor secret for your user.. TFA will
not be enabled until you have successfully confirmed the code you
were given with the `tfa-enable-confirm` endpoint (see below). Once
enabled, login from untrusted computers will be required to provide
a TFA code before they are successful.
operationId: tfaEnable
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Two Factor secret generated
content:
application/json:
schema:
type: object
properties:
secret:
type: string
description: >
Your two-factor secret. This is used to generate
time-based two factor codes required for login. Doing
this will be required to confirm TFA an actually enable it.
example: 5FXX6KLACOC33GTC
expiry:
type: string
format: date-time
description: >
When this Two Factor secret expires.
example: 2018-03-01T00:01:01
default:
$ref: '#/components/responses/ErrorResponse'
/profile/tfa-enable-confirm:
post:
tags:
- profile
summary: Confirm and enable Two Factor Authentication for your user.
description: >
Confirms that you can successfully generate Two Factor codes and
enables TFA on your account. Once this is complete, login attempts
from untrusted computers will be required to provide a Two Factor code
before they are successful.
operationId: tfaConfirm
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The Two Factor code you generated with your Two Factor secret.
required: true
content:
application/json:
schema:
type: object
properties:
tfa_code:
type: string
description: >
The Two Factor code you generated with your Two Factor secret.
These codes are time-based, so be sure it is current.
example: "213456"
responses:
'200':
description: TFA enabled successfully
content:
application/json:
schema:
type: object
properties:
scratch:
type: string
description: >
A one-use code that can be used in place of your Two Factor
code, in case you are unable to generate one. Keep this in
a safe place to avoid being locked out of your account.
example: sample two factor scratch
default:
$ref: '#/components/responses/ErrorResponse'
/profile/tfa-disable:
post:
tags:
- profile
summary: Disabled Two Factor Authentication for your user.
description: >
Disabled Two Factor Authentication for your user. Once successful,
login attempts from untrusted computers will only require a password
before being successful. This is less secure, and is discouraged.
operationId: tfaDisable
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: TFA disabled.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/profile/tokens:
description: >
A collection of Personal Access Tokens you've created.
get:
tags:
- profile
summary: Lists active Personal Access Tokens.
description: >
Returns a paginated list of Personal Access Tokens currently active for
your user.
operationId: getPersonalAccessTokens
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: A paginated list of active tokens.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/PersonalAccessToken'
default:
$ref: '#/components/responses/ErrorResponse'
post:
tags:
- profile
summary: Create a new Personal Access Token
description: >
Creates a new Personal Access Token for your user. The raw token will
be returned in the response, but will never be returned again afterward
so be sure to take note of it. You may create a token with _at most_
the scopes of your current token. The created token will be able to
access your account until the given expiry, or until it is revoked.
operationId: createPersonalAccessToken
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Information about the requested token.
required: true
content:
application/json:
schema:
type: object
required:
- label
properties:
scopes:
type: string
format: oauth-scope
description: >
The scopes to create the token with. These cannot be changed
after creation, and may not exceed the scopes of the acting token.
If omitted, the new token will have the same scopes as the acting
token.
example: '*'
expiry:
type: string
format: date-time
description: >
When this token should be valid until. If omitted, the new token
will be valid until it is manually revoked.
example: null
label:
$ref: '#/components/schemas/PersonalAccessToken/properties/label'
responses:
'200':
description: Token created successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/PersonalAccessToken'
default:
$ref: '#/components/responses/ErrorResponse'
/profile/tokens/{tokenId}:
description: View or revoke a single token.
parameters:
- name: tokenId
in: path
description: The ID of the token to access.
required: true
schema:
type: integer
format: int32
get:
tags:
- profile
summary: View a single token
description: >
Returns a single Personal Access Token.
operationId: getPersonalAccessToken
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: The requested token.
content:
application/json:
schema:
$ref: '#/components/schemas/PersonalAccessToken'
default:
$ref: '#/components/responses/ErrorResponse'
put:
tags:
- profile
summary: Update information about a token.
description: >
Updates a Personal Access Token's label.
operationId: updatePersonalAccessToken
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: The fields to update.
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/PersonalAccessToken'
responses:
'200':
description: Token updated successfully.
content:
application/json:
schema:
$ref: '#/components/schemas/PersonalAccessToken'
default:
$ref: '#/components/responses/ErrorResponse'
delete:
tags:
- profile
summary: Revoke a Personal Access Token.
description: >
Immediately revokes a Personal Access Token. The token will be invalidated
immediately, and requests using that token will fail with a 401. It _is_
possible to revoke access to the token making the request to revoke a token,
but keep in mind that doing so could lose you access to the api and require
you to create a new token through some other means.
operationId: deletePersonalAccessToken
security:
- personalAccessToken: []
- oauth:
- account:read_write
responses:
'200':
description: Token revoked successfully.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/support/tickets:
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- support
summary: Lists your Support Tickets.
description: >
This endpoint returns a collection of Support Tickets on your
account. Support Tickets can be both tickets you open with Linode
for support, as well as tickets generated by Linode and regarding
your account.
This collection includes all Support Tickets generated on your account,
with open tickets returned first.
operationId: getTickets
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a paginated list of SupportTicket objects.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/SupportTicket'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- support
summary: Create a Support Ticket.
description: >
Create a Support Ticket.
Only one of the ID attributes (`linode_id`, `domain_id`, etc) can be set
on a single Support Ticket.
operationId: createTicket
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Create a Support Ticket.
content:
application/json:
schema:
$ref: '#/components/schemas/SupportTicketRequest'
responses:
'200':
description: Support Ticket created.
content:
application/json:
schema:
$ref: '#/components/schemas/SupportTicket'
default:
$ref: '#/components/responses/ErrorResponse'
/support/tickets/{ticketId}:
parameters:
- name: ticketId
in: path
description: The ID of the Support Ticket.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
tags:
- support
summary: View a specific Support Ticket under your account.
description: >
This endpoint returns a Support Ticket under your account.
operationId: getTicket
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a SupportTicket object.
content:
application/json:
schema:
$ref: '#/components/schemas/SupportTicket'
default:
$ref: '#/components/responses/ErrorResponse'
/support/tickets/{ticketId}/attachments:
parameters:
- name: ticketId
in: path
description: The ID of the Support Ticket.
required: true
schema:
type: integer
format: int32
post:
x-linode-grant: read_write
tags:
- support
summary: Add a file attachment to a Support Ticket.
description: >
This endpoint allows you to add a file attachment to an existing Support
Ticket on your account. File attachments are used to assist our
Support team in resolving your Support Ticket. Examples of attachments
are screen shots and text files that provide additional information.
operationId: createTicketAttachment
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Add an attachment.
required: true
content:
multipart/form-data:
schema:
type: object
required:
- file
properties:
file:
type: string
description: >
The local, absolute path to the file you want to attach to
your Support Ticket.
example: '/Users/LinodeGuy/pictures/screen_shot.jpg'
responses:
'200':
description: Attachment created.
content:
application/json:
schema:
type: object
default:
$ref: '#/components/responses/ErrorResponse'
/support/tickets/{ticketId}/replies:
parameters:
- name: ticketId
in: path
description: The ID of the Support Ticket.
required: true
schema:
type: integer
format: int32
get:
x-linode-grant: read_only
parameters:
- $ref: '#/components/parameters/pageOffset'
- $ref: '#/components/parameters/pageSize'
tags:
- support
summary: Lists the replies to a specific Support Ticket.
description: >
This endpoint returns a collection of replies to a singular Support
Ticket on your account.
operationId: getTicketReplies
security:
- personalAccessToken: []
- oauth:
- account:read_only
responses:
'200':
description: Returns a paginated list of SupportTicketReply objects.
content:
application/json:
schema:
type: object
allOf:
- $ref: '#/components/schemas/PaginationEnvelope'
- properties:
data:
type: array
items:
$ref: '#/components/schemas/SupportTicketReply'
default:
$ref: '#/components/responses/ErrorResponse'
post:
x-linode-grant: read_write
tags:
- support
summary: Reply to a Support Ticket.
description: >
This endpoint allows you to add a reply to an existing Support Ticket.
operationId: createTicketReply
security:
- personalAccessToken: []
- oauth:
- account:read_write
requestBody:
description: Add a reply.
required: true
content:
application/json:
schema:
type: object
required:
- description
properties:
description:
type: string
description: >
The content of your reply.
minLength: 1
maxLength: 65535
example: >
Thank you for your help. I was able to figure out what the
problem was and I successfully reset my password. You guys are
the best!
responses:
'200':
description: Reply created.
content:
application/json:
schema:
$ref: '#/components/schemas/SupportTicketReply'
default:
$ref: '#/components/responses/ErrorResponse'
components:
securitySchemes:
personalAccessToken:
type: http
description: |
A Personal Access Token is an OAuth 2.0 Access Token that you can generate for your own
personal use through the [Linode Cloud Manager](https://cloud.linode.com/profile/tokens).
All scopes defined for the `oauth` security model, apply to this security model as well.
scheme: bearer
oauth:
type: oauth2
flows:
authorizationCode:
authorizationUrl: 'https://login.linode.com/oauth/authorize'
tokenUrl: 'https://login.linode.com/oauth/token'
scopes:
'account:read_only': Allows access to GET information about your account.
'account:read_write': Allows access to all endpoints related to your account.
'domains:read_only': Allows access to GET Domains on your account.
'domains:read_write': Allows access to all Domain endpoints.
'events:read_only': Allows access to GET your Events.
'events:read_write': Allows access to all endpoints related to your Events.
'images:read_only': Allows access to GET your images.
'images:read_write': Allows access to all endpoints related to your images.
'ips:read_only': Allows access to GET your ips.
'ips:read_write': Allows access to all endpoints related to your ips.
'linodes:read_only': Allow access to GET Linodes on your account
'linodes:read_write': Allow access to all endpoints related to your Linodes.
'longview:read_only': Allows access to GET your Longview clients.
'longview:read_write': Allows access to all endpoints related to your Longview clients.
'nodebalancers:read_only': Allows access to GET NodeBalancers on your account.
'nodebalancers:read_write': Allows access to all NodeBalancer endpoints.
'stackscripts:read_only': Allows access to GET your StackScripts.
'stackscripts:read_write': Allows access to all endpoints related to you StackScripts.
'volumes:read_only': Allows access to GET your Volumes.
'volumes:read_write': Allows access to all endpoints related to your Volumes.
responses:
ErrorResponse:
description: >
An error occurred during your request. In most cases, this is something you can fix by
changing the request parameters and submitting another request. Look to the content of the
request to see what needs to be done.
content:
application/json:
schema:
type: object
properties:
errors:
type: array
items:
$ref: '#/components/schemas/ErrorObject'
parameters:
pageOffset:
name: page
in: query
description: The page of a collection to return.
required: false
schema:
type: integer
format: int32
minimum: 1
default: 1
pageSize:
name: page_size
in: query
description: The number of items to return per page.
schema:
type: integer
format: int32
minimum: 25
maximum: 100
default: 100
links:
bootLinode:
operationId: bootLinodeInstance
parameters:
linodeId: '$request.body#/id'
rebootLinode:
operationId: rebootLinodeInstance
parameters:
linodeId: '$request.body#/id'
shutdownLinode:
operationId: shutdownLinodeInstance
parameters:
linodeId: '$request.body#/id'
updateLinode:
operationId: updateLinodeInstance
parameters:
linodeId: '$request.body#/id'
deleteLinode:
operationId: deleteLinodeInstance
parameters:
linodeId: '$request.body#/id'
rebuildLinode:
operationId: rebuildLinodeInstance
parameters:
linodeId: '$request.body#/id'
mutateLinode:
operationId: mutateLinodeInstance
parameters:
linodeId: '$request.body#/id'
resizeLinode:
operationId: resizeLinodeInstance
parameters:
linodeId: '$request.body#/id'
rescueLinode:
operationId: rescueLinodeInstance
parameters:
linodeId: '$request.body#/id'
cloneLinode:
operationId: cloneLinodeInstance
parameters:
linodeId: '$request.body#/id'
attachVolume:
operationId: attachVolume
parameters:
volumeID: '$request.body#/id'
cloneVolume:
operationId: cloneVolume
parameters:
volumeId: '$request.body#/id'
detachVolume:
operationId: detachVolume
parameters:
volumeId: '$request.body#/id'
resizeVolume:
operationId: resizeVolume
parameters:
volumeId: '$request.body#/id'
schemas:
Account:
type: object
description: Account object
properties:
address_1:
type: string
description: First line of this Account's billing address.
maxLength: 64
example: 123 Main Street
address_2:
type: string
description: Second line of this Account's billing address.
maxLength: 64
example: Suite A
balance:
type: number
readOnly: true
description: This Account's balance, in US dollars.
example: 200
city:
type: string
description: The city for this Account's billing address.
maxLength: 24
example: Philadelphia
company:
type: string
description: The company name associated with this Account.
maxLength: 128
example: Linode LLC
country:
type: string
description: >
The two-letter country code of this Account's billing address.
minLength: 2
maxLength: 2
example: US
email:
type: string
description: The email address of the person associated with this Account.
maxLength: 128
example: john.smith@linode.com
first_name:
type: string
description: The first name of the person associated with this Account.
maxLength: 50
example: John
last_name:
type: string
description: The last name of the person associated with this Account.
maxLength: 50
example: Smith
phone:
type: string
description: The phone number associated with this Account.
maxLength: 32
example: 215-555-1212
state:
type: string
description: >
If billing address is in the United States, this is the State
portion of the Account's billing address. If the address is outside
the US, this is the Province associated with the Account's billing
address.
maxLength: 24
example: Pennsylvania
tax_id:
type: string
description: >
Your tax identification, for tax calculations in some countries.
If you do not live in a country that collects tax, this should be null.
maxLength: 100
example: ATU99999999
zip:
type: string
description: The zip code of this Account's billing address.
maxLength: 16
example: 19102
AccountSettings:
type: object
description: Account Settings object
properties:
managed:
type: boolean
readOnly: true
description: >
Our 24/7 incident response service. This robust, multi-homed
monitoring system distributes monitoring checks to ensure that your
servers remain online and available at all times. Linode Managed can
monitor any service or software stack reachable over TCP or HTTP.
Once you add a service to Linode Managed, we'll monitor it for
connectivity, response, and total request time. This guide shows
you how to start monitoring your services with Linode Managed.
example: true
longview_subscription:
type: string
description: >
The Longview Pro tier you are currently subscribed to. The value must
be null or an id from `GET /longview/subscriptions`.
example: longview-30
network_helper:
type: boolean
description: >
Enables network helper by default across all users by default for
new Linodes or Linode Configs.
example: false
Backup:
type: object
description: >
An object representing a Backup or snapshot for a Linode with Backup service
enabled.
properties:
id:
type: integer
format: int32
readOnly: true
description: The unique ID of this Backup.
example: 123456
type:
type: string
enum:
- auto
- snapshot
readOnly: true
description: >
This indicates whether the Backup is an automatic Backup, or a
manual snapshot taken by the user at a specific point in time.
example: snapshot
status:
type: string
enum:
- paused
- pending
- running
- needsPostProcessing
- successful
- failed
- userAborted
readOnly: true
description: The current state of a specific Backup.
example: successful
created:
type: string
format: date-time
readOnly: true
description: The date the Backup was taken.
example: '2018-01-15T00:01:01'
updated:
type: string
format: date-time
readOnly: true
description: The date the Backup was most recently updated.
example: '2018-01-15T00:01:01'
finished:
type: string
format: date-time
readOnly: true
description: The date the Backup completed.
example: '2018-01-15T00:01:01'
label:
type: string
description: A label for Backups that are of type snapshot
example: Webserver-Backup-2018
configs:
type: array
items:
type: string
example: My Debian 9 Config
readOnly: true
description: >
A list of the labels of the configuration profiles that are part
of the Backup.
disks:
type: array
items:
type: object
properties:
size:
type: integer
format: int32
example: 9001
filesystem:
$ref: '#/components/schemas/Disk/properties/filesystem'
label:
type: string
example: My Debian 9 Disk
readOnly: true
description: >
A list of the disks that are part of the Backup.
CreditCard:
type: object
description: >
An object representing the credit card information you have on file with
Linode to make payments against your account.
required:
- card_number
- expiry_month
- expiry_year
properties:
card_number:
type: string
description: Your credit card number. No spaces or dashes allowed.
minLength: 16
maxLength: 16
example: 4111111111111111
expiry_month:
type: integer
format: int32
description: >
A value from 1-12 representing the expiration month of your credit card.
* 1 = January, 2 = February, 3 = March, etc
example: 12
expiry_year:
type: integer
format: int32
description: >
A four-digit integer representing the expiration month of
your credit card.
The combination of `expiry_month` and `expiry_year`
must result in a month/year combination of the current month or in
the future. An expiration date set in the past is invalid.
example: 2020
ErrorObject:
type: object
description: >
An object for describing a single error that occurred during the processing of a request.
properties:
reason:
type: string
description: >
What happened to cause this error. In most cases, this can be fixed immediately by
changing the data you sent in the request, but in some cases you will be instructed to
open a support ticket or perform some other action before you can complete the request
successfully.
example: Helpful error message goes here.
field:
type: string
description: >
The field in the request that caused this error. This may be a path, separated by
periods in the case of nested fields. In some cases this may come back as "null" if the
error is not specific to any single element of the request.
example: null
Event:
type: object
description: >
A collection of Event objects. An Event is an action taken against an
entity related to your Account. For example, booting a Linode would
create an Event.
The events returned depends on your grants.
properties:
id:
type: integer
format: int32
readOnly: true
description: The unique ID of this Event.
example: 123456
action:
type: string
readOnly: true
description: The action that caused this Event.
example: ticket_create
created:
type: string
readOnly: true
format: date-time
description: When this Event was created.
example: '2018-01-01T00:01:01'
entity:
type: object
readOnly: true
description: >
Detailed information about the event's entity, including ID, type,
label, and URL used to access it.
properties:
id:
type: integer
format: int32
description: The unique ID for this event's entity.
example: 11111
label:
type: string
description: >
The current label of this object. The label may reflect changes
that occur with this Event.
example: Problem booting my Linode
type:
type: string
description: >
The type of entity this Event is related to.
example: ticket
url:
type: string
description: >
The URL where you can access the object this Event is for. If
a relative URL, it is relative to the domain you retrieved the
Event from.
example: /v4/support/tickets/11111
percent_complete:
type: integer
format: int32
readOnly: true
description: >
A percentage estimating the amount of time remaining for an Event.
Returns `null` for notification events.
example: null
rate:
type: string
readOnly: true
description: >
The rate of completion of the Event. Only some Events will return
percent_complete; for example, migration and resize events.
example: null
read:
type: boolean
readOnly: true
description: If this Event has been read.
example: true
seen:
type: boolean
readOnly: true
description: If this Event has been seen.
example: true
status:
type: string
readOnly: true
description: The current status of this Event.
enum:
- failed
- finished
- notification
- scheduled
- started
time_remaining:
type: integer
format: int32
readOnly: true
description: >
The estimated time remaining until the completion of this Event.
Currently, this value is only returned for in-progress events.
example: null
username:
type: string
readOnly: true
description: >
The username of the User who caused the Event.
example: exampleUser
ImagePublic:
type: object
description: Public Image object
properties:
id:
type: string
description: The unique ID of this Image.
example: linode/ubuntu17.10
readOnly: true
label:
x-linode-filterable: true
type: string
description: >
A short description of the Image.
example: Ubuntu 17.10
created:
type: string
format: date-time
description: When this Image was created.
example: '2018-01-01T00:01:01'
readOnly: true
created_by:
type: string
description: >
The name of the user who created this Image, or linode for
official Images.
example: linode
readOnly: true
deprecated:
x-linode-filterable: true
type: boolean
description: >
Whether or not this Image is deprecated. Will only be true for
deprecated public Images.
example: false
readOnly: true
description:
type: string
description: An optional detailed description of this Image.
example: null
is_public:
x-linode-filterable: true
description: True if the Image is public.
type: boolean
example: true
readOnly: true
size:
x-linode-filterable: true
type: integer
format: int32
description: >
The minimum size this Image needs to deploy. Size is in MB.
example: 2500
readOnly: true
type:
type: string
description: >
How the Image was created. Manual Images can be created at any time.
Automatic Images are created automatically from a deleted Linode.
enum:
- manual
- automatic
example: manual
readOnly: true
vendor:
x-linode-filterable: true
type: string
description: >
The upstream distribution vendor. Consistent between releases of a
distro. `None` for private Images.
example: Ubuntu
readOnly: true
ImagePrivate:
type: object
description: Private Image object
properties:
id:
type: string
description: The unique ID of this Image.
example: private/67848373
readOnly: true
label:
x-linode-filterable: true
type: string
description: >
A short description of the Image. Labels cannot contain
special characters.
example: My gold-master image
created:
type: string
format: date-time
description: When this Image was created.
example: '2018-01-01T00:01:01'
readOnly: true
created_by:
type: string
description: >
The name of the user who created this Image.
example: somename
readOnly: true
deprecated:
x-linode-filterable: true
type: boolean
description: >
Whether or not this Image is deprecated. Will only be true for
deprecated public Images.
example: false
readOnly: true
description:
type: string
description: An optional detailed description of this Image.
example: The detailed description of my Image.
is_public:
x-linode-filterable: true
description: True if the Image is public.
type: boolean
example: false
readOnly: true
size:
x-linode-filterable: true
type: integer
format: int32
description: >
The minimum size this Image needs to deploy. Size is in MB.
example: 2500
readOnly: true
type:
type: string
description: >
How the image was created. Manual images can be created at any time.
Automatic images are created automatically from a deleted Linode.
enum:
- manual
- automatic
example: manual
readOnly: true
vendor:
x-linode-filterable: true
type: string
description: >
The upstream distribution vendor. Consistent between releases of a
distro. `None` for private images.
example: null
readOnly: true
Invoice:
type: object
description: Account Invoice object
properties:
id:
type: integer
format: int32
readOnly: true
description: The Invoice's unique ID.
example: 123
date:
type: string
readOnly: true
format: date-time
description: When this Invoice was generated.
example: '2018-01-01T00:01:01'
label:
type: string
readOnly: true
description: The Invoice's display label.
example: Invoice
overdue:
type: boolean
readOnly: true
description: Whether or not the Invoice is overdue for payment.
example: false
paid:
type: boolean
readOnly: true
description: Whether or not the Invoice has been paid.
example: true
total:
type: integer
readOnly: true
description: The amount of the Invoice in US Dollars.
example: 120
InvoiceItem:
type: object
description: An InvoiceItem object.
properties:
amount:
type: integer
readOnly: true
description: The price, in US dollars, of unitprice multiplied by quantity.
example: 20
from:
type: string
readOnly: true
format: date-time
description: The date the Invoice Item started, based on month.
example: '2018-01-01T00:01:01'
label:
type: string
readOnly: true
description: The invoice item's display label.
example: Linode 123
quantity:
type: integer
format: int32
readOnly: true
description: The quantity of this item for the specified Invoice.
example: 1
to:
type: string
readOnly: true
format: date-time
description: The date the Invoice Item ended, based on month.
example: '2018-01-31T11:59:59'
type:
type: string
readOnly: true
description: The type of service, ether `prepay` or `misc`.
enum:
- hourly
- prepay
- misc
unitprice:
type: integer
format: int32
readOnly: true
description: The monthly service fee, in US Dollars, for this item.
example: 10
Kernel:
type: object
description: Linux kernel object
properties:
id:
type: string
description: The unique ID of this kernel.
example: linode/latest-64bit
readOnly: true
label:
x-linode-filterable: true
type: string
description: The friendly name of this kernel.
example: Latest 64 bit (4.15.7-x86_64-linode102)
readOnly: true
version:
x-linode-filterable: true
type: string
description: Linux kernel version.
example: 4.15.7
readOnly: true
kvm:
x-linode-filterable: true
type: boolean
description: If this kernel is suitable for KVM Linodes.
example: true
readOnly: true
xen:
x-linode-filterable: true
type: boolean
description: If this kernel is suitable for Xen Linodes.
example: false
readOnly: true
architecture:
x-linode-filterable: true
type: string
description: The architecture of this kernel.
enum:
- x86_64
- i386
example: x86_64
readOnly: true
pvops:
x-linode-filterable: true
type: boolean
description: If this kernel is suitable for paravirtualized operations.
example: false
readOnly: true
LinodeBase:
type: object
description: Common properties for Linode Request and Response objects.
properties:
label:
type: string
title: This Linode's unique label.
description: >
The Linode's label is for display purposes only. If no label is provided for a Linode,
a default will be assigned.
Linode labels have the following constraints:
* Must start with an alpha character.
* Must consist of alphanumeric characters, dashes (`-`), and underscores (`_`).
* Cannot not have two dash (`-`) or underscores (`_`) in a row.
example: linode123
minLength: 3
maxLength: 32
pattern: '^[a-zA-Z]((?!--|__)[a-zA-Z0-9-_])+$'
type:
$ref: '#/components/schemas/LinodeType/properties/id'
region:
$ref: '#/components/schemas/Region/properties/id'
group:
type: string
title: The group this Linode is in.
description: >
Some tools will use this property to group Linodes for display. Linodes are not required
to have a group.
example: Linode-Group
maxLength: 50
LinodeRequest:
type: object
description: Common properties for creating and rebuilding Linodes.
properties:
image:
$ref: '#/components/schemas/DiskRequest/properties/image'
root_pass:
$ref: '#/components/schemas/DiskRequest/properties/root_pass'
authorized_keys:
$ref: '#/components/schemas/DiskRequest/properties/authorized_keys'
stackscript_id:
$ref: '#/components/schemas/DiskRequest/properties/stackscript_id'
stackscript_data:
$ref: '#/components/schemas/DiskRequest/properties/stackscript_data'
booted:
type: boolean
title: If the Linode should start booted.
writeOnly: true
description: >
This field defaults to `true` if the Linode is created with an Image or from a
Backup.
If it is deployed from an Image or a Backup and you wish it to remain `offline`
after deployment, set this to `false`.
LinodeStats:
type: object
description: >
CPU, IO, IPv4, and IPv6 statistics. Graph data, if available,
is in "[timestamp, reading]" array format. Timestamp is a UNIX timestamp
in EST.
readOnly: true
properties:
cpu:
type: array
description: >
Percentage of CPU used.
items:
type: number
example: [1521483600000, 0.42]
io:
type: object
description: Input/Output statistics.
properties:
io:
type: array
description: Block/s written.
items:
type: number
example:
- 1521484800000
- 0.19
swap:
type: array
description: Block/s written.
items:
type: number
example:
- 1521484800000
- 0
netv4:
type: object
description: IPv4 statistics.
properties:
in:
type: array
description: Input stats for IPv4, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 2004.36
out:
type: array
description: Output stats for IPv4, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 3928.91
private_in:
type: array
description: Private IPv4 input statistics, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 0
private_out:
type: array
description: Private IPv4 output statistics, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 5.6
netv6:
type: object
description: IPv6 statistics.
properties:
in:
type: array
description: Input stats for IPv6, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 0
out:
type: array
description: Output stats for IPv6, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 0
private_in:
type: array
description: Private IPv6 input statistics, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 195.18
private_out:
type: array
description: Private IPv6 output statistics, measured in bits/s (bits/second).
items:
type: number
example:
- 1521484800000
- 5.6
title:
type: string
description: The title for this data set.
example: linode.com - my-linode (linode123456) - day (5 min avg)
LinodeType:
type: object
description: >
Returns collection of Linode types, including pricing and specifications
for each type. These are used when creating or resizing Linodes.
properties:
id:
type: string
title: The ID representing the Linode type.
example: g5-standard-2
label:
x-linode-filterable: true
type: string
readOnly: true
title: This Linode Type's label.
description: >
The Linode Type's label is for display purposes only.
example: Linode 4096
disk:
x-linode-filterable: true
type: integer
format: int32
readOnly: true
title: Disk space in MB.
description: >
The Disk size of the Linode type, in MB.
example: 49152
class:
x-linode-filterable: true
type: string
readOnly: true
title: The class of the Linode type.
description: >
We currently offer three classes of Linodes:
* nanode - Our entry-level Linode type.
* standard - Our flagship Linode type.
* highmem - A Linode type featuring high memory availability.
enum:
- nanode
- standard
- himem
example: standard
price:
type: object
readOnly: true
title: Cost (in US dollars) for this type.
description: >
Cost in US dollars, broken down into hourly and monthly charges.
properties:
hourly:
type: integer
title: Cost (in US dollars) per hour.
example: 0.03
monthly:
type: integer
title: Cost (in US dollars) per month.
example: 20
addons:
type: object
readOnly: true
title: Addon services that are available for this Linode type.
description: >
A list of optional addon services for Linodes and their associated
costs.
properties:
backups:
type: object
readOnly: true
title: Optional Backups service.
description: >
Information about the optional Backup service offered for Linodes.
properties:
price:
type: object
title: Cost of enabling Backups for this Linode type.
properties:
hourly:
type: integer
title: Cost per hour.
description: >
The cost (in US dollars) per hour to add Backups service.
example: 0.008
monthly:
type: integer
title: Cost per month.
description: >
The cost (in US dollars) per month to add Backups service.
example: 5
network_out:
x-linode-filterable: true
type: integer
format: int32
readOnly: true
title: Outbound bandwidth allocation.
description: >
The Mbits outbound bandwidth allocation.
example: 1000
memory:
x-linode-filterable: true
type: integer
format: int32
readOnly: true
title: RAM
description: >
Amount of RAM included in this Linode type.
example: 4096
transfer:
x-linode-filterable: true
type: integer
format: int32
readOnly: true
title: Outbound transfer.
description: >
The monthly outbound transfer amount, in MB.
example: 3000
vcpus:
x-linode-filterable: true
type: integer
format: int32
readOnly: true
title: Number of CPU cores.
description: >
The number of VCPU cores this Linode type offers.
example: 2
LinodeConfig:
type: object
required:
- label
- devices
properties:
id:
type: integer
format: int32
title: The ID of this Config.
example: 23456
kernel:
type: string
title: A kernel ID to boot a Linode with. Defaults to 'linode/latest-64bit'
example: linode/latest-64bit
comments:
type: string
title: Optional field for arbitrary user comments on this Config.
example: This is my main Config
memory_limit:
type: integer
title: The maximum RAM the Linode will be given when booting this Config.
description: >
Defaults to the total RAM of the Linode.
example: 2048
root_device_ro:
type: boolean
title: Controls whether or not to mount the root Disk as read-only.
description: Defaults to false.
example: false
run_level:
type: string
title: Stes the run level for the Linode boot.
description: >
One of:
* default
* single (for single user mode)
* binbash
enum:
- default
- single
- binbash
example: default
virt_mode:
type: string
title: Controls the virtualization mode.
description: >
One of:
* paravirt (default)
* fullvirt
example: paravirt
helpers:
type: object
title: Helpers enabled when booting to this Linode Config.
properties:
updatedb_disabled:
type: boolean
title: Disables updatedb cron job to avoid disk thrashing.
example: true
distro:
type: boolean
title: Helps maintain correct inittab/upstart console device.
example: true
modules_dep:
type: boolean
title: Creates a modules dependency file for the kernel you run.
example: true
network:
type: boolean
title: Automatically configure static networking.
example: true
devtmpfs_automount:
type: boolean
title: Populates the /dev directory early during boot without udev.
description: Defaults to false
example: false
label:
x-linode-filterable: true
type: string
title: Label for the Config.
description: >
The Config's label is for display purposes only.
example: My Config
minLength: 1
maxLength: 48
devices:
$ref: '#/components/schemas/Devices'
Disk:
type: object
properties:
id:
type: integer
title: The ID of this Disk.
description: >
This Disk's ID which must be provided for all
operations impacting this Disk.
example: 25674
readOnly: true
label:
x-linode-filterable: true
type: string
title: Label for the Disk.
description: >
The Disk's label is for display purposes only.
example: Debian 9 Disk
minLength: 1
maxLength: 48
status:
type: string
description: >
A brief description of this Disk's current state. This field may change without
direct action from you - for instance, if the status is "not ready," the next time you
request the same Disk object it may be "ready." All statuses except for
"ready" are transitory. A Disk in one of these statuses will
transition to another status when it has completed this transitory action.
example: ready
readOnly: true
enum:
- ready
- not ready
- deleting
size:
x-linode-filterable: true
type: integer
format: int32
readOnly: true
title: The size of the Disk in MB.
example: 48640
filesystem:
type: string
title: The filesystem on the Disk.
readOnly: true
description: >
The Disk filesystem can be one of:
* raw - No filesystem, just a raw binary stream
* swap - Linux swap area
* ext3 - The ext3 journaling filesystem for Linux
* ext4 - The ext4 journaling filesystem for Linux
* initrd - initrd (uncompressed initrd, ext2, max 32 MB)
example: ext4
enum:
- raw
- swap
- ext3
- ext4
- initrd
created:
type: string
format: date-time
description: When this Linode was created.
example: '2018-01-01T00:01:01'
readOnly: true
updated:
type: string
format: date-time
description: When this Linode was last updated.
example: '2018-01-01T00:01:01'
readOnly: true
DiskRequest:
type: object
description: Disk object request.
required:
- size
- label
properties:
size:
$ref: '#/components/schemas/Disk/properties/size'
label:
$ref: '#/components/schemas/Disk/properties/label'
filesystem:
$ref: '#/components/schemas/Disk/properties/filesystem'
read_only:
type: boolean
description: >
If true, this Disk is read-only.
example: false
image:
type: string
title: An Image identifier.
description: >
An image id to deploy the disk from. Official Linode images start with
`linode/ `, while your images start with `private`.
See `/images` for more information on the images available for you to use.
example: linode/debian9
authorized_keys:
type: array
items:
type: string
title: A list of public SSH keys.
writeOnly: true
example:
- ssh-rsa AAAA_valid_public_ssh_key_123456785== user@their-computer
description: >
This is an optional list of public SSH keys that will be automatically appended
to the root user's `~/.ssh/authorized_keys` file.
root_pass:
type: string
format: password
title: Set the root user's password.
writeOnly: true
example: aComplexP@ssword
description: |
This will set the root user's password on the newly created Linode.
The root password must conform to the following constraints:
* May only use alphanumerics, punctuation, spaces, and tabs
* Must contain at least two of the following characters classes:
* Upper-case letters
* Lower-case letters
* Digits
* Punctuation
minLength: 6
maxLength: 128
pattern: ^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9]))|((?=.*[a-z])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\]))|((?=.*[A-Z])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\]))|((?=.*[0-9])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\])))
stackscript_id:
type: integer
title: The ID of a StackScript to deploy.
example: 10079
description: |
A StackScript ID that will cause the referenced StackScript to be run during
deployment of this Linode. A compatible `image` is required to use a
StackScript. To get a list of available StackScript and their permitted images
see `GET /stackscripts`.
You may only deploy from a StackScript that you own or that is listed as
`public`.
This field cannot be used when deploying from a backup or a user made image.
stackscript_data:
type: object
title: Optional user-defined field data for this StackScript.
example:
gh_username: linode
description: |
This field is required only if the StackScript being deployed requires input
data from the user for successful completion.
See `GET /linode/stackscript/{stackScriptId}` for more details.
This field is required to be valid JSON.
Device:
type: object
description: >
Device can be either a Disk or Volume identified by `disk_id` or
`volume_id`. Only one type per slot allowed.
* sda: The device mapped to /dev/sda. Can be null.
* sdb: The device mapped to /dev/sdb. Can be null.
* sdc: The device mapped to /dev/sdc. Can be null.
* sdd: The device mapped to /dev/sdd. Can be null.
* sde: The device mapped to /dev/sde. Unavailable in `fullvirt` virt_mode.
* sdf: The device mapped to /dev/sdf. Unavailable in `fullvirt` virt_mode.
* sdg: The device mapped to /dev/sdg. Unavailable in `fullvirt` virt_mode.
* sdh: The device mapped to /dev/sdh. Unavailable in `fullvirt` virt_mode.
properties:
disk_id:
type: integer
title: The ID of the Disk.
description: Null if a volume is assigned to this slot.
example: 124458
volume_id:
type: integer
title: The ID of the Volume.
description: Null if a disk is assigned to this slot.
example: null
Domain:
type: object
description: >
A domain zonefile in our DNS system. You must own the domain name and
tell your registrar to use Linode's nameservers in order for a domain
in our system to be treated as authoritative.
required:
- id
properties:
id:
type: integer
format: int32
description: This Domain's unique ID
example: 1234
readOnly: true
type:
type: string
enum:
- master
- slave
description: >
If this Domain represents the authoritative source of information for
the domain it describes, or if it is a read-only copy of a master
(also called a slave).
example: master
domain:
type: string
pattern: ([a-zA-Z0-9-_]+\.)+([a-zA-Z]{2,3}\.)?([a-zA-Z]{2,16}|XN--[a-zA-Z0-9]+)
description: >
The domain this Domain represents. These must be unique in our
system, you cannot have two Domains representing the same domain.
example: example.org
x-linode-filterable: true
group:
type: string
description: >
The group this Domain belongs to. This is for display purposes
only.
example: null
minLength: 1
maxLength: 50
x-linode-filterable: true
status:
type: string
enum:
- disabled
- active
- edit_mode
description: >
Used to control whether this domain is currently being rendered.
example: active
description:
type: string
minLength: 1
maxLength: 255
description: |
A description for this domain. This is for display purposes only.
example: null
soa_email:
type: string
format: email
description: >
Start of Authority email address. This is required for master
domains.
example: admin@example.org
retry_sec:
type: integer
format: int32
description: >
The interval at which a failed refresh should be retried, in
seconds. Valid values are 300, 3600, 7200, 14400, 28800, 57600,
86400, 172800, 345600, 604800, 1209600, and 2419200 - any other
value will be rounded to the nearest valid value.
example: 300
master_ips:
type: array
items:
type: string
format: ip
description: >
The IP addresses representing the master DNS for this domain.
example: []
axfr_ips:
type: array
items:
type: string
format: ip
description: >
The list of IPs that may perform a zone transfer for this domain.
This is potentially dangerous, and should be set to an empty list
unless you intend to use it.
example: []
expire_sec:
type: integer
format: int32
description: >
The amount of time that may pass before this domain is no longer
authoritative, in seconds. Valid values are
300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600,
604800, 1209600, and 2419200 - any other value will be rounded to
the nearest valid value.
example: 300
refresh_sec:
type: integer
format: int32
description: >
The amount of time before this domain should be refreshed, in
seconds. Valid values are
300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600,
604800, 1209600, and 2419200 - any other value will be rounded to
the nearest valid value.
example: 300
ttl_sec:
type: integer
format: int32
description: >
"Time to Live" - the amount of time, in seconds, that this domain's
records may be cached by resolvers or other domain servers. Valid
values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800,
345600, 604800, 1209600, and 2419200 - any other value will be
rounded to the nearest valid value.
example: 300
DomainRecord:
type: object
description: >
A single record on a domain.
properties:
id:
type: integer
format: int32
description: This record's unique ID.
example: 123456
readOnly: true
type:
type: string
enum:
- A
- AAAA
- NS
- MX
- CNAME
- TXT
- SRV
- PTR
- CAA
description: >
The type of record this is in the DNS system. For example, A
records associate a domain name with an ipv4 address, and AAAA
records associate a domain name with an ipv6 address.
example: A
name:
type: string
description: >
The name of this record. This field's actual usage depends on the
type of record this represents. For A and AAAA records, this is
the subdomain being assocaited with an ip address.
minLength: 1
maxLength: 100
example: test
target:
type: string
description: >
The target for this record. This field's actual usage depends on
the type of record this represents. For A and AAAA records, this
is the address the named domain should resolve to.
example: 12.34.56.78
priority:
type: integer
format: int32
minimum: 0
maximum: 255
description: >
The priority of the target host. Lower values are preferred.
example: 50
weight:
type: integer
format: int32
description: >
The relative weight of this record. Higher values are preferred.
example: 50
port:
type: integer
format: int32
description: >
The port this record points to.
example: 80
service:
type: string
description: >
The service this record identified. Only valid for SRV records.
example: null
protocol:
type: string
description: >
The protocol this record's service communicates with. Only valid
for SRV records.
example: null
ttl_sec:
type: integer
format: int32
description: >
"Time to Live" - the amount of time, in seconds, that this domain's
records may be cached by resolvers or other domain servers. Valid
values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800,
345600, 604800, 1209600, and 2419200 - any other value will be
rounded to the nearest valid value.
example: 604800
tag:
type: string
description: >
The tag portion of a CAA record. It is invalid to set this on
other record types.
example: null
IPAddress:
description: >
An IP address that exists in Linode's system, either v4 or v6.
properties:
address:
type: string
format: ip
description: >
The address.
example: 97.107.143.141
readOnly: true
gateway:
type: string
format: ip
description: >
The default gateway for this address.
example: 97.107.143.1
readOnly: true
subnet_mask:
type: string
format: ip
description: >
The mask that separates host bits from network bits for this address.
example: 255.255.255.0
readOnly: true
prefix:
type: integer
format: int32
description: >
The number of bits set in the subnet mask.
example: 24
readOnly: true
type:
type: string
enum:
- public
- private
- slaac
- link_local
description: >
The type of address this is.
example: public
readOnly: true
rdns:
type: string
description: >
The reverse-dns assigned to this address. For public v4 addresses,
this will be set to a default value provided by Linode if not
explicitly set.
example: li740-141.members.linode.com
linode_id:
type: integer
format: int32
description: >
The ID of the Linode this address currently belongs to. For v4
addresses, this is by default the Linode that this address was
assigned to on creation, and these addresses my be moved using the
/networking/ipv4/assign endpoint. For slaac and link_local
addresses, this value may not be changed.
example: 123
readOnly: true
region:
type: string
description: >
The region this address resides in.
example: us-east
readOnly: true
x-linode-filterable: true
IPv6Pool:
description: >
An object representing an IPv6 pool.
properties:
range:
type: string
description: >
The IPv6 pool
example: '2600:3c01::02:5000::'
readOnly: true
region:
type: string
description: >
An IPv6 Pool is a pool of IPv6 addresses that are routed to all of
your Linodes in a single region. Any Linode you own may bring up any
address in this pool at any time, with no external configuration
required.
example: us-east
readOnly: true
IPv6Range:
description: >
An object representing an IPv6 range.
properties:
range:
type: string
description: >
The IPv6 range.
example: '2600:3c01::02:5000::'
readOnly: true
region:
type: string
description: >
A range of IPv6 addresses routed to a single Linode in the given
region. Your Linode is responsible for routing individual addresses
in the range, or handling traffic for all of the addresses in the
range.
example: us-east
readOnly: true
NodeBalancer:
description: >
Linode's load balancing solution. Can handle multiple ports, ssl termination,
and any number of backends. NodeBalancer ports are configured with
NodeBalancerConfigs, and each config is given one or more NodeBalancerNode that
accepts traffic. The traffic should be routed to the NodeBalancer's ip address,
the NodeBalancer will handle routing individual requests to backends.
properties:
id:
type: integer
format: int32
description: >
This NodeBalancer's unique ID.
example: 12345
readOnly: true
label:
x-linode-filterable: true
type: string
minLength: 3
maxLength: 32
pattern: '[a-zA-Z0-9-_]{3,32}'
description: >
This NodeBalancer's label. These must be unique on your account.
example: balancer12345
region:
x-linode-filterable: true
type: string
description: >
The region where this NodeBalancer is located. NodeBalancers only
support backends in the same region as they are.
example: us-east
readOnly: true
hostname:
type: string
description: >
This NodeBalancer's hostname, ending with .nodebalancer.linode.com
example: nb-207-192-68-16.newark.nodebalancer.linode.com
readOnly: true
ipv4:
type: string
format: ip
description: >
This NodeBalancer's public IPv4 address.
example: 12.34.56.78
readOnly: true
ipv6:
type: string
format: ip
description: >
This NodeBalancer's public IPv6 address.
example: null
readOnly: true
created:
type: string
format: date-time
description: >
When this NodeBalancer was created.
example: 2018-01-01T00:01:01
readOnly: true
updated:
type: string
format: date-time
description: >
When this NodeBalancer was last updated.
example: 2018-03-01T00:01:01
readOnly: true
client_conn_throttle:
type: integer
format: int32
minimum: 0
maximum: 20
description: >
Throttle connections per second. Set to 0 to disable throttling.
example: 0
NodeBalancerConfig:
description: >
A NodeBalancer config represents the configuration of this NodeBalancer
on a single port. For example, a NodeBalancer config on port 80 would
typically represent how this NodeBalancer response to http requests.
NodeBalaner configs have a list of backends, called "nodes," that they
forward requests between based on their configuration.
properties:
id:
type: integer
format: int32
description: This config's unique ID
example: 4567
readOnly: true
port:
type: integer
format: int32
minimum: 1
maximum: 65535
description: >
The port this config is for. These values must be unique across configs
on a single NodeBalancer (you can't have two configs for port 80, for
example). While some ports imply some protocols, no enforcement is done
and you may configure your NodeBalancer however is useful to you (for
example, while port 443 is generally used for https, you do not need
ssl configured to have a NodeBalancer listening on port 443).
example: 80
protocol:
type: string
enum:
- http
- https
- tcp
description: >
The protocol this port is configured to serve. If this is set to "https,"
you must include an ssl_cert and an ssl_key.
example: http
algorithm:
type: string
enum:
- roundrobin
- leastconn
- source
description: >
What algorithm this NodeBalancer should use for routing traffic to backends.
example: roundrobin
stickiness:
type: string
enum:
- none
- table
- http_cookie
description: >
Controls how session stickiness is handled on this port. If set to `none,`
connections will always be assigned a backend based on the algorithm configured.
If `table,` sessions from the same remote address will be routed to the same
backend. For http or https clients, `http_cookie` allows sessions to be
routed to the same backend based on a cookie set by the NodeBalancer.
example: http_cookie
check:
type: string
enum:
- none
- connection
- http
- http_body
description: >
The type of check to perform against backends to ensure they are serving
requests. This is used to determine if backends are up or down. If `none,`
no check is performed. `connection` requires only a connection to the
backend to succeed. `http` and `http_body` rely on the backend serving
http, and that the response returned is expected.
example: http_body
check_interval:
type: integer
format: int32
description: >
How often to check that backends are up and serving requests, in seconds.
example: 90
check_timeout:
type: integer
format: int32
minimum: 1
maximum: 30
description: >
How long to wait for a check attempt before considering it failed, in seconds.
example: 10
check_attempts:
type: integer
format: int32
minimum: 1
maximum: 30
description: >
How many times to attempt a check before considering a backend to be down.
example: 3
check_path:
type: string
description: >
The URL path to check on each backend. If the backend does not respond
to this request, it is considered to be down.
example: /test
check_body:
type: string
description: >
This value must be present in the response body of the check in order for
it to pass. If this value is not present in the response body of a check
request, the backend is considered to be down.
example: it works
check_passive:
type: boolean
description: >
If true, any response from this backend with a 5xx status code will be
enough for it to be considered unhealthy and taken out of rotation.
example: true
cipher_suite:
type: string
enum:
- recommended
- legacy
description: >
What ciphers to use for ssl connections served by this NodeBalancer.
`legacy` is considered insecure and should only be used if necessary.
example: recommended
nodebalancer_id:
type: integer
format: int32
description: >
The ID for the NodeBalancer this config belongs to.
example: 12345
readOnly: true
ssl_commonname:
type: string
description: >
The common name for the SSL certification this port is serving. null
if this port is not configured to use ssl.
example: null
readOnly: true
ssl_fingerprint:
type: string
description: >
The fingerprint for the SSL certification this port is serving. null
if this port is not configured to use ssl.
example: null
readOnly: true
ssl_cert:
type: string
description: >
The certificate this port is serving. This is not returned, and if set
will come back as "<REDACTED>". Please use the ssl_commonname and
ssl_fingerprint to identify the certificate.
example: null
ssl_key:
type: string
description: >
The private key corresponding to this port's certificate. This is not
returned, and will come back as "<REDACTED>" if set. Please use the
ssl_commonname and ssl_fingerprint to identify the certificate.
example: null
node_status:
type: object
description: >
A structure containing information about the health of the backends
for this port. This information is updated periodically as checks
are performed against backends.
readOnly: true
properties:
up:
type: integer
format: int32
description: >
The number of backends considered to be "UP" and healthy, and that
are serving requests.
example: 4
readOnly: true
down:
type: integer
format: int32
description: >
The number of backends considered to be "DOWN" and unhealthy. These
are not in rotation, and not serving requests.
example: 0
readOnly: true
NodeBalancerNode:
description: >
A NodeBalancerNode represents a single backend serving requests for a single
port of a NodeBalancer. Nodes are specific to NodeBalancerConfigs, and serve
traffic over their private IP. If the same Linode is serving traffic for more
than one port on the same NodeBalancer, one NodeBalancerNode is required for
each config (port) it should serve requests on. For example, if you have
four backends, and each should response to both http and https requests, you
will need two NodeBalancerConfigs (port 80 and port 443) and four backends
each - one for each of the Linodes serving requests for that port.
properties:
id:
type: integer
format: int32
description: This node's unique ID.
example: 54321
readOnly: true
address:
type: string
format: ip
description: >
The private IP Address this backend can be reached at. This _must_
be a private IP address.
example: 192.168.210.120
label:
type: string
minLength: 3
maxLength: 32
description: >
The label for this node. This is for display purposes only.
example: node54321
status:
type: string
enum:
- unknown
- UP
- DOWN
description: >
The current status of this node, based on the configured checks
of its NodeBalancer Config.
example: UP
readOnly: true
weight:
type: integer
minimum: 1
maximum: 255
description: >
Used when picking a backend to serve a request and is not pinned to
a single backend yet. Nodes with a higher weight will receive more
traffic.
example: 50
mode:
type: string
enum:
- accept
- reject
- drain
description: >
If set to `accept,` this backend is accepting traffic. If set to
`reject,` this backend will not receive traffic. If set to `drain,`
this backend will not receive _new_ traffic, but connections already
pinned to it will continue to be routed to it.
example: accept
config_id:
type: integer
format: int32
description: >
The NodeBalancerConfig ID that this node belongs to.
example: 4567
readOnly: true
nodebalancer_id:
type: integer
format: int32
description: >
The NodeBalancer ID that this node belongs to.
example: 12345
readOnly: true
Notification:
type: object
description: >
An important, often time-sensitive item related to your account.
properties:
entity:
type: object
readOnly: true
description: Detailed information about the Notification.
properties:
id:
type: integer
format: int32
description: >
The unique ID of the notification's entity, based on the entity
type.
example: 3456
label:
type: string
description: >
The current label for this Notification's entity.
example: Linode not booting.
type:
type: string
description: The type of entity this is related to.
example: ticket
url:
type: string
description: >
The URL where you can access the object this Notification is for.
If a relative URL, it is relative to the domain you retrieved the
Notification from.
example: /support/tickets/3456
label:
type: string
description: >
A short description of this notification.
example: You have an important ticket open!
readOnly: true
message:
type: string
readOnly: true
description: A human-readable description of the Notification.
example: You have an important ticket open!
type:
type: string
enum:
- migration_scheduled
- migration_pending
- reboot_scheduled
- outage
- payment_due
- ticket_important
- ticket_abuse
- notice
readOnly: true
description: The type of Notification this is.
example: ticket_important
severity:
type: string
enum:
- minor
- major
- critical
description: >
The severity of this Notification. This field can be used to
decide how prominently to display the Notification, what color
to make the display text, etc.
example: major
readOnly: true
when:
type: string
readOnly: true
format: date-time
description: >
If this notification is of an event that will happen at a fixed,
future time, this is when the named action will be taken. For
example, if a Linode is to be migrated in response to a
Security Advisory, this field will contain around the time the
Linode will be taken offline for migration.
example: null
until:
type: string
format: date-time
description: >
If this notification has a duration, this will be the ending time
for the event or action. For example, if there is scheduled
maintenance for one of our systems, `until` would be set to the end
of the maintenance window.
example: null
readOnly: true
OAuthClient:
description: >
A third-party application registered to Linode that users may log into
with their Linode account through our authentication server at
https://login.linode.com. Using an OAuth Client, a third-party
developer may be given access to some, or all, of a user's account for
the purposes of their application.
properties:
id:
type: string
description: >
The OAuth Client ID. This is used to identify the client, and is a
publicly-known value (it is not a secret).
example: 2737bf16b39ab5d7b4a1
readOnly: true
redirect_uri:
type: string
format: url
description: >
The location a successful login from https://login.linode.com should be
redirected for this client. The receiver of this redirect should be
ready to accept an OAuth exchange code and finish the OAuth exchange.
example: https://example.org/oauth/callback
label:
x-linode-filterable: true
type: string
minLength: 1
maxLength: 512
description: >
The name of this application. This will be presented to users when they
are asked to grant it access to their account.
example: Example App
status:
type: string
enum:
- active
- disabled
- suspended
description: >
The status of this application. `active` by default.
example: active
readOnly: true
secret:
type: string
description: >
The OAuth Client Secret, used in the OAuth exchange. This is returned
as `<REDACTED>` except when an OAuth Client is created or its secret
is reset. This _is_ a secret, and should not be shared or disclosed
publicly.
example: <REDACTED>
readOnly: true
thumbnail_url:
type: string
format: url
description: >
The URL where this client's thumbnail may be viewed, or `null` if this client
does not have a thumbnail set.
example: https://api.linode.com/v4/account/clients/2737bf16b39ab5d7b4a1/thumbnail
readOnly: true
public:
x-linode-filterable: true
type: boolean
description: >
If this is a public or private OAuth Client. Public clients have a slightly
different authentication workflow than private clients. See the OAuth spec
for more details.
example: false
readOnly: true
PaginationEnvelope:
type: object
description: >
An envelope for paginated response. When accessing a collection through a GET endpoint, the
results are wrapped in this envelope which includes metadata about those results.
required:
- pages
- page
- results
- data
properties:
data:
type: array
items:
type: object
readOnly: true
pages:
type: integer
format: int32
readOnly: true
example: 1
page:
type: integer
format: int32
readOnly: true
example: 1
results:
type: integer
format: int32
readOnly: true
example: 1
RescueDevices:
type: object
properties:
sda:
$ref: '#/components/schemas/Device'
sdb:
$ref: '#/components/schemas/Device'
sdc:
$ref: '#/components/schemas/Device'
sdd:
$ref: '#/components/schemas/Device'
sde:
$ref: '#/components/schemas/Device'
sdf:
$ref: '#/components/schemas/Device'
sdg:
$ref: '#/components/schemas/Device'
Devices:
allOf:
- $ref: '#/components/schemas/RescueDevices'
properties:
sdh:
$ref: '#/components/schemas/Device'
Linode:
allOf:
- $ref: '#/components/schemas/LinodeBase'
properties:
label:
x-linode-filterable: true
region:
x-linode-filterable: true
readOnly: true
description: >
This is the location where the Linode was deployed. This cannot be
changed without opening a support ticket.
image:
x-linode-filterable: true
readOnly: true
allOf:
- $ref: '#/components/schemas/DiskRequest/properties/image'
type:
readOnly: true
description: >
This is the Linode service plan type that this Linode was deployed
with.
To change a Linode's type, use
`POST /linode/instances/{linodeId}/resize`.
group:
x-linode-filterable: true
id:
type: integer
title: The ID of this Linode.
description: >
This Linode's ID which must be provided for all operations impacting this Linode.
example: 123
readOnly: true
status:
type: string
description: >
A brief description of this Linode's current state. This field may change without
direct action from you - for instance, if the status is "booting," the next time you
request the same Linode object it may be "running." Most statuses, except for
"offline" and "running", are transitory. A Linode in one of these statuses will
transition to another status when it has completed this transitory action.
example: running
readOnly: true
enum:
- running
- offline
- booting
- rebooting
- shutting_down
- provisioning
- deleting
- migrating
- rebuilding
- cloning
- restoring
hypervisor:
type: string
description: >
The virtualization software powering this Linode. Xen is no longer available, and is
only used by legacy Linodes at this time.
example: kvm
readOnly: true
enum:
- kvm
- xen
created:
type: string
format: date-time
description: When this Linode was created.
example: '2018-01-01T00:01:01'
readOnly: true
updated:
type: string
format: date-time
description: When this Linode was last updated.
example: '2018-01-01T00:01:01'
readOnly: true
ipv4:
type: array
items:
type: string
example:
- 123.45.67.890
readOnly: true
description: |
This Linode's IPv4 Addresses. Each Linode is assigned a single public IPv4 address
upon creation, and may get a single private IPv4 address if needed. You may need to
open a support ticket to get additional IPv4 addresses.
IPv4 addresses may be reassigned between your Linodes, or shared with other Linodes.
See the `/networking` endpoints for details.
ipv6:
type: string
description: >
This Linode's IPv6 slaac addresses. This address is specific to a Linode, and may not
be shared.
example: 'c001:d00d::1234'
readOnly: true
specs:
type: object
description: Information about the resources available to this Linode.
readOnly: true
properties:
disk:
type: integer
format: int32
description: >
The amount of storage space this Linode has access to, in GB. A typical Linode
will divide this space between a primary disk with an `image` deployed to it, and
a swap disk, usually 512 MB. This is the default configuration created when
deploying a Linode with an `image` through `POST /linode/instances`. While this
configuration is suitable for 99% of use cases, if you need finer control over
your Linode's disks, see the `/linode/instances/{linodeId}/disks` endpoints.
example: 30720
readOnly: true
memory:
type: integer
format: int32
description: >
The amount of RAM this Linode has access to, in MB. Typically a Linode will
choose to boot with all of its available RAM, but this can be configured in a
Config Profile, see the `/linode/instances/{linodeId}/configs` endpoints and the
LinodeConfig object for more information.
example: 2048
readOnly: true
vcpus:
type: integer
format: int32
description: >
The number of vcpus this Linode has access to. Typically a Linode will choose to
boot with all of its available vcpus, but this can be configured in a Config
Profile, see the `/linode/instances/{linodeId}/configs` endpoints and the
LinodeConfig object for more information.
example: 1
readOnly: true
transfer:
type: integer
format: int32
description: The amount of network transfer this Linode is allotted each month.
example: 2000
readOnly: true
alerts:
type: object
properties:
cpu:
type: integer
description: >
The percentage of CPU usage required to trigger an alert. If the average CPU
usage over two hours exceeds this value, we'll send you an alert. If this is set
to 0, the alert is disabled.
example: 90
network_in:
type: integer
description: >
The amount of incoming traffic, in Mbit/s, required to trigger an alert. If the
average incoming traffic over two hours exceeds this value, we'll send you an
alert. If this is set to 0, the alert is disabled.
example: 10
network_out:
type: integer
description: >
The amount of outbound traffic, in Mbit/s, required to trigger an alert. If the
average outbound traffic over two hours exceeds this value, we'll send you an
alert. If this is set to 0, the alert is disabled.
example: 10
transfer_quota:
type: integer
description: >
The percentage of network transfer that may be used before an alert is triggered.
When this value is exceeded, we'll alert you. If this is set to 0, the alert is
disabled.
example: 80
io:
type: integer
description: >
The amount of disk IO operation per second required to trigger an alert. If the
average disk IO over two hours exceeds this value, we'll send you an alert. If set
to 0, this alert is disabled.
example: 10000
backups:
type: object
description: >
Information about this Linode's backups status. For information about available
backups, see `GET /linode/instances/{linodeId}/backups`.
properties:
enabled:
type: boolean
description: >
If this Linode has the backup service enabled. To enable backups, see
`POST /linode/instances/{linodeId}/backups/enable`.
example: true
readOnly: true
schedule:
type: object
properties:
day:
type: string
description: |
The day of the week that your Linode's weekly backup is taken. If you do not
set this, a day will be chosen for you. Backups are taken every day, but
backups taken on this day are preferred when selecting backups to retain for a
longer period.
If you do not set this manually, then when backups are initially enabled, this
may come back as `Scheduling` until the `day` is automatically selected.
example: Saturday
enum:
- Scheduling
- Sunday
- Monday
- Tuesday
- Wednesday
- Thursday
- Friday
- Saturday
window:
type: string
description: |
The window in which your backups will be taken, in UTC. A backups window is a
two-hour span of time in which the backup may occur. For example, W10
indicates that your backups should be taken between 10:00 and 12:00. If you do
not choose a backup window, one will be selected for you automatically.
If you do not set this manually, then when backups are initially enabled, this
may come back as `Scheduling` until the `window` is automatically selected.
example: W22
enum:
- Scheduling
- W0
- W2
- W4
- W8
- W10
- W12
- W14
- W16
- W18
- W20
- W22
Region:
type: object
description: An area where Linode services are available.
properties:
id:
type: string
title: The unique ID of this region.
description: The unique ID of this region.
example: us-east
country:
type: string
title: The country where this region resides.
description: The country where this region resides.
example: us
readOnly: true
LongviewClient:
description: >
A LongviewClient is a single monitor set up to track statistics about
one of your servers.
properties:
id:
type: integer
format: int32
description: >
This Client's unique ID.
example: 789
readOnly: true
label:
x-linode-filterable: true
type: string
minLength: 3
maxLength: 32
pattern: '[a-zA-Z0-9-_]{3,32}'
description: >
This Client's unique label. This is for display purposes only.
example: client789
api_key:
type: string
description: >
The API key for this Client, used when configuring the Longview
Client application on your server.
example: BD1B4B54-D752-A76D-5A9BD8A17F39DB61
readOnly: true
install_code:
type: string
description: >
The install code for this Client, used when configuring the Longview
CLient application on your server.
example: BD1B5605-BF5E-D385-BA07AD518BE7F321
readOnly: true
apps:
type: object
description: >
The apps this Client is monitoring on your server. This is configured
when you install the Longview Client application, and is present here
only for your information.
readOnly: true
properties:
apache:
type: boolean
description: >
If true, the Apache Longview Client module is monitoring Apache on
your server.
example: true
readOnly: true
nginx:
type: boolean
description: >
If true, the nginx Longview Client module is monitoring nginx on
your server.
example: false
readOnly: true
mysql:
type: boolean
description: >
If true, the MySQL Longview Client modules is monitoring MySQL on
your server.
example: true
readOnly: true
created:
type: string
format: date-time
description: >
When this Longview Client was created.
example: 2018-01-01T00:01:01
readOnly: true
updated:
type: string
format: date-time
description: >
When this Longview Client was last updated.
example: 2018-01-01T00:01:01
readOnly: true
LongviewSubscription:
description: >
A Longview Subscriptions represents a tier of Longview service you
can subscribe to.
properties:
id:
type: string
description: >
The unique ID of this subscription tier.
example: longview-10
readOnly: true
price:
type: object
description: >
Pricing information about this Longview Subscription tier.
readOnly: true
properties:
hourly:
type: number
description: >
The hourly price for this subscription tier, in US Dollars.
example: 0.06
readOnly: true
monthly:
type: number
description: >
The maximum monthly price for this subscription tier, in US
Dollars. You will never be charged more than this amount per
month for this subscription.
example: 40
readOnly: true
label:
type: string
description: >
A display name for this subscription tier.
example: Longivew Pro 10 pack
readOnly: true
clients_included:
type: integer
format: int32
description: >
The number of Longview Clients that may be created with this tier.
example: 10
readOnly: true
ManagedContact:
description: >
Information about someone Linode's special forces may contact
in case an issue is detected with a manager service.
properties:
id:
type: integer
format: int32
description: >
This contact's unique ID.
example: 567
readOnly: true
name:
type: string
minLength: 2
maxLength: 64
pattern: '[a-zA-Z0-9-_ ]{2,64}'
description: >
The name of this contact
example: John Doe
email:
type: string
format: email
description: >
The address to email this contact to alert them of issues.
example: john.doe@example.org
phone:
type: object
description: >
Information about how to reach this contact by phone.
properties:
primary:
type: string
format: phone
description: >
This contact's primary phone number.
example: 123-456-7890
secondary:
type: string
format: phone
description: >
This contact's secondary phone number.
example: null
group:
x-linode-filterable: true
type: string
minLength: 2
maxLength: 50
description: >
A grouping for this contact. This is for display purposes only.
example: on-call
updated:
type: string
format: date-time
description: >
When this contact was last updated.
example: '2018-01-01T00:01:01'
readOnly: true
ManagedCredential:
description: >
A credential, stored securely, that allows Linode's special forces
to access a managed server to respond to issues.
properties:
id:
type: integer
format: int32
description: >
This credential's unique ID.
example: 9991
readOnly: true
label:
type: string
minLength: 2
maxLength: 75
pattern: '[a-zA-Z0-9-_ \.]{2,75}'
description: >
The unique label for this credential. This is for display purposes
only.
example: prod-password-1
ManagedIssue:
description: >
An issue that was detected with a service Linode is managing.
properties:
id:
type: integer
format: int32
description: >
This issue's unique ID.
example: 823
readOnly: true
created:
type: string
format: date-time
description: >
When this issue was created. Issues are created in response to issues
detected with managed services, so this is also when the issue was
detected.
example: '2018-01-01T00:01:01'
readOnly: true
services:
type: array
items:
type: integer
format: int32
example: 654
description: >
An array of Managed Service IDs that were affected by this issue.
readOnly: true
entity:
type: object
description: >
The ticket this Managed Issue opened.
readOnly: true
properties:
id:
type: integer
format: int32
description: >
This ticket's ID
example: 98765
readOnly: true
type:
type: string
enum:
- ticket
description: >
The type of entity this is. In this case, it is always a ticket.
example: ticket
readOnly: true
label:
type: string
description: >
The summary for this ticket.
example: Managed issue opened!
readOnly: true
url:
type: string
format: url
description: >
The relative URL where you can access this ticket.
example: /support/tickets/98765
readOnly: true
ManagedLinodeSettings:
description: >
Settings for a specific Linode related to Managed Services. There is
one ManagedLinodeSettings object for each Linode on your account.
properties:
id:
type: integer
format: int32
description: >
The ID of the Linode these settings are for.
example: 123
readOnly: true
label:
type: string
description: >
The label of the Linode these settings are for.
example: linode123
readOnly: true
group:
type: string
description: >
The group of the Linode these settings are for. This is for display
purposes only.
example: linodes
readOnly: true
ssh:
type: object
description: >
The SSH settings for this Linode.
properties:
access:
type: boolean
description: >
If true, Linode special forces may access this Linode over
ssh to respond to issues.
example: true
user:
type: string
minLength: 0
maxLength: 32
description: >
The user Linode's special forces should use when accessing this
Linode to respond to an issue.
example: linode
ip:
type: string
format: ip
description: >
The IP Linode special forces should use to access this Linode
when responding to an issue.
example: 12.34.56.789
port:
type: integer
format: int32
minimum: 1
maximum: 65535
description: >
The port Linode special forces should use to access this Linode
over ssh to respond to an issue.
example: 22
ManagedService:
description: >
A service that Linode is monitoring as part of your managed services.
If issues are detected with this service, a ManagedIssue will be opened
and, optionally, Linode special forces will attempt to resolve the issue.
properties:
id:
type: integer
format: int32
description: >
This service's unique ID.
example: 9944
readOnly: true
status:
type: string
enum:
- disabled
- pending
- ok
- problem
description: >
The current status of this service.
example: ok
readOnly: true
service_type:
type: string
enum:
- URL
- TCP
description: >
How this service is monitored.
example: URL
label:
type: string
minLength: 3
maxLength: 64
pattern: '[a-zA-Z0-9-_ \.]{3,64}'
description: >
The label for this service. This is for display purposes only.
example: prod-1
address:
type: string
format: url
minLength: 3
description: >
The URL at which this service is monitored.
example: https://example.org
timeout:
type: integer
format: int32
minimum: 1
maximum: 255
description: >
How long to wait, in seconds, for a response before considering the
service to be down.
example: 30
body:
type: string
minLength: 0
maxLength: 100
description: >
What to expect to find in the response body for the service to be
considered up.
example: it worked
consultation_group:
type: string
minLength: 0
maxLength: 50
description: >
The group of ManagedContacts who should be notified or consulted
with when an issue is detected.
example: on-call
notes:
type: string
description: >
Any information relevant to the service that Linode special forces
should know when attempting to resolve issues.
example: The service name is my-cool-application
region:
type: string
description: >
The region in which this service is located. This is required if
address is a private IP, and may not be set otherwise.
example: null
credentials:
type: array
items:
type: integer
format: int32
example: 9991
description: >
An array of ManagedCredential ids that should be used when attempting to
resolve issues with this service.
created:
type: string
format: date-time
description: When this Managed Service was created.
example: '2018-01-01T00:01:01'
readOnly: true
updated:
type: string
format: date-time
description: When this Managed Service was last updated.
example: '2018-03-01T00:01:01'
readOnly: true
StackScript:
description: >
A StackScript enables you to quickly deploy a
fully-configured application in an automated manner.
properties:
id:
type: integer
format: int32
description: The unique ID of this StackScript.
example: 1337
readOnly: true
username:
type: string
title: The user who created the StackScript.
description: >
The user who created the StackScript.
example: rmcintosh
readOnly: true
user_gravatar_id:
type: string
title: The author's Gravatar ID
description: >
The Gravatar ID for the user who
created the StackScript, if one is available.
example: a445b305abda30ebc766bc7fda037c37
readOnly: true
label:
x-linode-filterable: true
type: string
title: A label for the StackScript.
description: >
The StackScript's label is for display purposes only.
example: a-stackscript
minLength: 3
maxLength: 128
description:
x-linode-filterable: true
type: string
description: >
A description for the StackScript.
example: >
This StackScript installs and configures a
LEMP stack.
images:
type: array
x-linode-filterable: true
description: >
The images that the StackScript is compatible for
deployment with. A list of Image IDs.
items:
type: string
example:
- linode/debian9
- linode/debian8
deployments_total:
type: integer
format: int32
title: The number of times the StackScript has been deployed.
description: >
The total number of times this StackScript has been deployed.
example: 12
readOnly: true
deployments_active:
type: integer
format: int32
title: The number of currently active deployments of this StackScript.
description: >
The count of only the still actively deployed Linodes created from
this StackScript.
example: 1
readOnly: true
is_public:
x-linode-filterable: true
type: boolean
title: Whether the StackScript is publicly accessible or not.
description: >
This determines whether other users can use your StackScript.
Once a StackScript is made public, it cannot be made private.
example: true
created:
type: string
format: date-time
title: The date the StackScript was created.
description: >
The date the StackScript was created.
readOnly: true
example: "2018-01-01T00:01:01"
updated:
type: string
format: date-time
title: The date the StackScript was last updated.
description: >
The date the StackScript was last updated.
readOnly: true
example: "2018-01-01T00:01:01"
rev_note:
x-linode-filterable: true
type: string
title: A note regarding the last revision of this StackScript.
description: >
This field allows you to leave notes when making revisions to StackScripts.
example: Added Debian 9 to supported images
script:
type: string
title: The StackScript.
description: >
This field is for inputting the contents of the StackScript.
example: #!/bin/sh
user_defined_fields:
type: array
title: A list of custom fields defined by the user using special tags within the StackScript.
description: >
This is a list of fields defined with a special syntax inside the StackScript
that allow for supplying customized parameters during deployment.
items:
$ref: '#/components/schemas/UserDefinedField'
readOnly: true
example:
label: Enter the DB password
name: DB_PASSWORD
example: hunter2
SupportTicket:
type: object
description: >
A Support Ticket opened on your Account.
properties:
id:
type: integer
format: int32
readOnly: true
description: >
The ID of the Support Ticket.
example: 11223344
attachments:
type: array
description: >
A list of filenames of attached files attached to this Support Ticket.
readOnly: true
items:
type: string
example:
- screenshot.jpg
- screenshot.txt
closed:
x-linode-filterable: true
type: string
format: date-time
readOnly: true
description: >
The date and time this ticket was closed.
example: '2015-06-04T16:07:03'
description:
type: string
readOnly: true
description: >
The full details of the issue or question.
minLength: 1
maxLength: 65000
example: >
I'm having trouble setting the root password on my Linode.
I tried following the instructions but something is not
working and I'm not sure what I'm doing wrong. Can you please
help me figure out how I can reset it?
entity:
type: object
readOnly: true
description: >
The entity this Support Ticket was opened for.
properties:
id:
type: integer
format: int32
readOnly: true
description: >
The unique ID for this ticket's entity.
example: 10400
label:
type: string
readOnly: true
description: >
The current label of this entity.
example: linode123456
type:
type: string
readOnly: true
description: >
The type of entity this is related to.
example: linode
url:
type: string
readOnly: true
description: >
The URL where you can access the object this event is
for. If a relative URL, it is relative to the domain you
retrieved the entity from.
example: /v4/linode/instances/123456
gravatar_id:
type: string
readOnly: true
description: >
The Gravatar ID of the user who opened this ticket.
example: 474a1b7373ae0be4132649e69c36ce30
opened:
x-linode-filterable: true
type: string
format: date-time
readOnly: true
description: >
The date and time this ticket was created.
example: '2015-06-04T14:16:44'
opened_by:
type: string
readOnly: true
description: >
The user who opened this ticket.
example: some_user
status:
type: string
readOnly: true
description: The current status of this Support Ticket.
enum:
- closed
- new
- open
example: open
summary:
type: string
readOnly: true
minLength: 1
maxLength: 64
description: >
The summary or title for this SupportTicket.
example: >
Having trouble resetting root password on my Linode
updated:
x-linode-filterable: true
type: string
format: date-time
readOnly: true
description: >
The date and time this ticket was last updated.
example: '2015-06-04T16:07:03'
updated_by:
type: string
readOnly: true
description: >
The user who last updated this ticket.
example: some_other_user
SupportTicketReply:
type: object
description: >
An object representing a reply to a Support Ticket.
properties:
created:
type: string
format: date-time
readOnly: true
description: >
The date and time this ticket reply was created.
example: '2015-06-02T14:31:41'
created_by:
type: string
readOnly: true
description: >
The user who submitted this reply.
example: John Q. Linode
description:
type: string
readOnly: true
description: >
The body of this Support Ticket reply.
example: >
Hello,\nI'm sorry to hear that you are having trouble resetting the
root password of your Linode. Just to be sure, have you tried to
follow the instructions in our online documentation? The link is here:\n
\nhttps://linode.com/docs/quick-answers/linode-platform/reset-the-root-password-on-your-linode/
\n\nIf you have, please reply with any additional steps you have also
taken.\n\nRegards, Linode Support Team
from_linode:
type: boolean
readOnly: true
description: >
If set to true, this reply came from a Linode employee.
example: true
gravatar_id:
type: string
readOnly: true
description: >
The Gravatar ID of the user who created this reply.
example: 474a1b7373ae0be4132649e69c36ce30
id:
type: integer
format: int32
readOnly: true
description: >
The unique ID of this Support Ticket reply.
example: 11223345
SupportTicketRequest:
type: object
required:
- summary
- description
description: >
An object representing a created Support Ticket - a question or issue
and request for help from the Linode support team.
Only one of the ID attributes (`linode_id`, `domain_id`, etc) can be set
on a single Support Ticket.
properties:
description:
type: string
description: >
The full details of the issue or question.
minLength: 1
maxLength: 65000
example: >
I'm having trouble setting the root password on my Linode.
I tried following the instructions but something is not
working and I'm not sure what I'm doing wrong. Can you please
help me figure out how I can reset it?
domain_id:
type: integer
format: int32
description: >
The ID of the Domain this ticket is regarding, if relevant.
example: null
linode_id:
type: integer
format: int32
description: >
The ID of the Linode this ticket is regarding, if relevant.
example: 123
longviewclient_id:
type: integer
format: int32
description: >
The ID of the Longview client this ticket is regarding, if relevant.
example: null
nodebalancer_id:
type: integer
format: int32
description: >
The ID of the NodeBalancer this ticket is regarding, if relevant.
example: null
summary:
type: string
minLength: 1
maxLength: 64
description: >
The summary or title for this SupportTicket.
example: >
Having trouble resetting root password on my Linode
volume_id:
type: integer
format: int32
description: >
The ID of the Volume this ticket is regarding, if relevant.
example: null
UserDefinedField:
type: object
required:
- label
- name
- example
description: >
A custom field defined by the user with a special syntax within a
StackScript. Derived from the contents of the script.
properties:
label:
type: string
description: >
A human readable label for the field that will serve as the input
prompt for entering the value during deployment.
example: Enter the password
readOnly: true
name:
type: string
description: >
The name of the field.
example: DB_PASSWORD
readOnly: true
example:
type: string
description: >
An example value for the field.
example: hunter2
readOnly: true
oneOf:
type: string
description: >
A list of acceptable single values for the field.
example: avalue,anothervalue,thirdvalue
readOnly: true
manyOf:
type: string
description: >
A list of acceptable values for the field in any quantity,
combination or order.
example: avalue,anothervalue,thirdvalue
readOnly: true
User:
description: >
A User on your account. Users can log in and access information about
your account. Unrestricted users have full access to everything on the
account, while restricted users may only access entities or perform
actions they've been granted access to.
properties:
username:
type: string
pattern: ^[a-zA-Z0-9]((?![_-]{2,})[a-zA-Z0-9-_])+[a-zA-Z0-9]$
minLength: 3
maxLength: 32
description: >
This user's username. This is used for logging in, and may also be
displayed alongside actions the user performs (for example, in Events
or public StackScripts).
x-linode-filterable: true
example: example_user
email:
type: string
format: email
description: >
The email address for this user. This is used for account management
communications, and may be used for other communications as configured.
example: example_user@linode.com
readOnly: true
restricted:
type: boolean
description: >
If true, this user must be granted access to perform actions or access
entities on this account. See `/account/users/{username}/grants` for
details on how to configure grants for a restricted user.
example: true
Volume:
type: object
required:
- label
description: >
A Block Storage Volume associated with your account.
properties:
id:
type: integer
format: int32
description: The unique ID of this Volume.
example: 12345
readOnly: true
label:
x-linode-filterable: true
type: string
title: Label for the Volume.
description: >
The Volume's label is for display purposes only.
example: my-volume
minLength: 1
maxLength: 32
pattern: '^[a-zA-Z]((?!--|__)[a-zA-Z0-9-_])+$'
status:
type: string
title: The status of the Volume.
description: >
Can be one of `creating`, `active`, `resizing`, `deleting`,
`deleted`, and `contact_support`:
* creating - the Volume is being created and is not yet available
for use.
* active - the Volume is online and available for use.
* resizing - the Volume is in the process of upgrading or downgrading
its current capacity.
* deleting - the Volume is being deleted and is unavailable for use.
* deleted - the Volume has been deleted.
* contact_support - there is a problem with your Volume. Please
open a support ticket to resolve the issue.
enum:
- creating
- active
- resizing
- deleting
- deleted
- contact_support
example: active
readOnly: true
size:
type: integer
title: The Volume's size, in GiB.
description: >
The Volume's size, in GiB. Minimum size is 10GiB, maximum size is 10240GiB.
minimum: 10
maximum: 10240
example: 20
region:
$ref: '#/components/schemas/Region/properties/id'
linode_id:
type: integer
title: The ID of the Linode this Volume is attached to, if applicable.
description: >
If a Volume is attached to a specific Linode, the ID of that Linode
will be displayed here.
example: 12346
created:
type: string
format: date-time
description: When this Volume was created.
example: '2018-01-01T00:01:01'
readOnly: true
updated:
type: string
format: date-time
description: When this Volume was last updated.
example: '2018-01-01T00:01:01'
readOnly: true
AuthorizedApp:
description: >
An application you have authorized access to your account through OAuth.
properties:
id:
type: integer
format: int32
description: >
This authorization's ID, used for revoking access.
example: 123
readOnly: true
label:
type: string
description: >
The name of the application you've authorized.
example: example-app
readOnly: true
thumbnail_url:
type: string
format: url
description: >
The URL at which this app's thumbnail may be accessed.
example: null
readOnly: true
scopes:
type: string
format: oauth-scopes
description: >
The OAuth scopes this app was authorized with. This defines what parts of your
account the app is allowed to access.
example: linodes:read_only
readOnly: true
created:
type: string
format: date-time
description: When this app was authorized.
example: '2018-01-01T00:01:01'
readOnly: true
x-linode-filterable: true
expiry:
type: string
format: date-time
description: >
When this app's access token expires. Please note that apps may still have active
refresh tokens after this time passes.
example: '2018-01-15T00:01:01'
readOnly: true
website:
type: string
format: url
description: >
The website where you can get more information about this app.
example: example.org
readOnly: true
PaymentRequest:
type: object
description: Payment object request.
required:
- cvv
- usd
properties:
cvv:
type: string
description: >
CVV (Card Verification Value) of the credit card to be used for
the payment.
example: '123'
usd:
type: string
description: >
The amount, in US Dollars, of the payment.
example: '120.50'
Payment:
type: object
description: Payment object response.
properties:
id:
type: integer
format: int32
readOnly: true
description: The unique ID of the payment.
example: 6291750
date:
type: string
readOnly: true
format: date-time
description: When the payment was made.
example: '2018-01-15T00:01:01'
usd:
type: integer
readOnly: true
description: The amount, in US dollars, of the payment.
example: '120.50'
PayPal:
type: object
required:
- cancel_url
- redirect_url
- usd
description: >
An object representing the staging of a payment via PayPal.
properties:
cancel_url:
type: string
description: The URL to have PayPal redirect to when payment is cancelled.
example: https://example.org
redirect_url:
type: string
description: The URL to have PayPal redirect to when payment is approved.
example: https://example.org
usd:
type: integer
description: The amount, in US dollars, of the payment.
example: '120.50'
PayPalExecute:
type: object
required:
- payer_id
- payment_id
description: >
An object representing an execution of payment to PayPal to capture the
funds and credit yoru Linode account.
properties:
payer_id:
type: string
description: >
The PayerID returned by PayPal during the transaction authorization
process.
example: ABCDEFGHIJKLM
payment_id:
type: string
description: >
The PaymentID returned from `POST /account/payments/paypal` that has
been approved with PayPal.
example: PAY-1234567890ABCDEFGHIJKLMN
PersonalAccessToken:
description: >
A Personal Access Token is a token generated manually to access the API
without going through an OAuth login. Personal Access Tokens can have
scopes just like OAuth tokens do, and are commonly used to give access
to command-line tools like the Linode CLI, or when writing your own
integrations.
properties:
id:
type: integer
format: int32
description: >
This token's unique ID, which can be used to revoke it.
example: 123
readOnly: true
scopes:
type: string
format: oauth-scopes
description: >
The scopes this token was created with. These define what parts of
the account the token can be used to access. Many command-line tools,
such as the Linode CLI, require tokens with access to `*`. Tokens with
more restrictive scopes are generally more secure.
example: '*'
readOnly: true
created:
type: string
format: date-time
description: >
The date and time this token was created.
x-linode-filterable: true
example: 2018-01-01T00:01:01
readOnly: true
label:
type: string
minLength: 1
maxLength: 100
description: >
This token's label. This is for display purposes only, but can be used to
more easily track what you're using each token for.
x-linode-filterable: true
example: linode-cli
token:
type: string
description: >
The token used to access the API. When the token is created, the full token
is returned here. Otherwise, only the first 16 characters are returned.
example: abcdefghijklmnop
readOnly: true
expiry:
type: string
format: date-time
description: >
When this token will expire. Personal Access Tokens cannot be renewed, so
after this time the token will be completely unusable and a new token will
need to be generated. Tokens may be created with "null" as their expiry
and will never expire unless revoked.
Profile:
description: >
A Profile represents your user in our system. This is where you can change
information about your user. This information is available to any OAuth Client
regardless of requested scopes, and can be used to populate user information
in third-party applications.
properties:
uid:
type: integer
format: int32
description: >
Your unique ID in our system. This value will never change, and can
safely be used to identify your user.
example: 1234
readOnly: true
username:
type: string
description: >
Your username, used for logging in to our system.
example: exampleUser
readOnly: true
email:
type: string
format: email
description: >
Your email address. This address will be used for communication with Linode
as necessary.
example: example-user@gmail.com
timezone:
type: string
description: >
The timezone you prefer to see times in. This is not used by the API, and is
for the benefit of clients only. All times the API returns are in UTC.
example: null
email_notifications:
type: boolean
description: >
If true, you will receive email notifications about account activity. If false,
you may still receive business-critical communications through email.
example: true
referrals:
type: object
description: >
Information about your status in our referral program.
readOnly: true
properties:
code:
type: string
description: >
Your referral code. If others use this when signing up for Linode, you will
receive account credit.
example: 871be32f49c1411b14f29f618aaf0c14637fb8d3
readOnly: true
url:
type: string
format: url
description: >
Your referral url, used to direct others to sign up for Linode with your referral
code.
example: https://www.linode.com/?r=871be32f49c1411b14f29f618aaf0c14637fb8d3
readOnly: true
total:
type: integer
format: int32
description: >
The number of users who have signed up with your referral code.
example: 0
readOnly: true
completed:
type: integer
format: int32
description: >
The number of completed signups with your referral code.
example: 0
readOnly: true
pending:
type: integer
format: int32
description: >
The number of pending signups with your referral code. You will not receive
credit for these signups until they are completed.
example: 0
readOnly: true
credit:
type: integer
format: int32
description: >
The amount of account credit issued to you through the referral
program, in US Dollars.
example: 0
readOnly: true
ip_whitelist_enabled:
type: boolean
description: >
If true, logins for your user will only be allowed from whitelisted IPs. See
`/profile/whitelist` for more information. This setting is currently deprecated,
and cannot be enabled. If you disable this setting, you will not be able to
re-enable it.
example: false
lish_auth_method:
type: string
enum:
- password_keys
- keys_only
- disabled
description: >
What methods of authentication are allowed when connecting via
Lish. "keys_only" is the most secure if you intend to use Lish,
and "disabled" is recommended if you do not intend to use Lish at
all.
example: keys_only
authorized_keys:
type: array
items:
type: string
format: ssh-key
description: >
The list of SSH Keys authorized to use Lish for your user. This value is ignored if
`lish_auth_method` is "disabled."
example: null
two_factor_auth:
type: boolean
description: >
If true, logins from untrusted computers will require two-factor
authentication. See `/profile/tfa-enable` to enable two-factor
authentication.
example: true
restricted:
type: boolean
description: >
If true, your user has restrictions on what can be accessed on your
account. To get details on what entities/actions you can
access/perform, see `/profile/grants`.
example: false
Transfer:
description: >
An object representing your network utilization for the current month,
in Gigabytes.
properties:
billable:
type: integer
format: int32
readOnly: true
description: >
The amount of your transfer pool that is billable this billing cycle.
example: 0
quota:
type: integer
format: int32
readOnly: true
description: >
The amount of network usage allowed this billing cycle.
example: 9141
used:
type: integer
format: int32
readOnly: true
description: >
The amount of network usage you have used this billing cycle.
example: 2
Grant:
description: >
Represents the level of access a restricted user has to a specific
resource on the account.
properties:
id:
type: integer
format: int32
description: >
The ID of the entity this grant applies to.
example: 123
readOnly: true
permissions:
type: string
enum:
- null
- read_only
- read_write
description: >
The level of access this user has to this entity. If null, this
user has no access.
example: read_only
label:
type: string
description: >
The current label of the entity this grant applies to, for display
purposes.
example: example-entity
readOnly: true
GrantsResponse:
description: >
A structure representing all grants a restricted user has on the
account. Not available for unrestricted users, as they have access to
everything without grants. If retrieved from the `/profile/grants`
endpoint, entities to which a user has no access will be omitted.
properties:
global:
type: object
description: >
A structure containing the account-level grants a user has.
properties:
add_linodes:
type: boolean
description: If true, this user may create Linodes.
example: true
add_longview:
type: boolean
description: If true, this user may create Longview clients.
example: true
longview_subscription:
type: boolean
description: If true, this user may manage the account's Longview subscription.
example: true
account_access:
type: string
enum:
- null
- read_only
- read_write
description: >
The level of access this user has to account-level actions,
like billing information. A restricted user will never be able
to manage users.
example: read_only
cancel_account:
type: boolean
description: If true, this user may cancel the entire account.
example: false
add_domains:
type: boolean
description: If true, this user may add Domains.
example: true
add_stackscripts:
type: boolean
description: If true, this user may add StackScripts.
example: true
add_nodebalancers:
type: boolean
description: If true, this user may add NodeBalancers.
example: true
add_images:
type: boolean
description: If true, this user may add Images.
example: true
add_volumes:
type: boolean
description: If true, this user may add Volumes.
example: true
linode:
type: array
items:
$ref: '#/components/schemas/Grant'
description: >
The grants this user has pertaining to Linodes on this account.
There will be one entry per Linode on the account.
domain:
type: array
items:
$ref: '#/components/schemas/Grant'
description: >
The grants this user has pertaining to Domains on this account.
There will be one entry per Domain on the account.
nodebalancer:
type: array
items:
$ref: '#/components/schemas/Grant'
description: >
The grants this user has pertaining to NodeBalancers on this
account. There will be one entry per NodeBalancer on the account.
image:
type: array
items:
$ref: '#/components/schemas/Grant'
description: >
The grants this user has pertaining to Images on this account.
There will be one entry per Image on the account.
longview:
type: array
items:
$ref: '#/components/schemas/Grant'
description: >
The grants this user has pertaining to Longview Clients on this
account. There will be one entry per Longview Client on the
account.
stackscript:
type: array
items:
$ref: '#/components/schemas/Grant'
description: >
The grants this user has pertaining to StackScripts on this
account. There will be one entry per StackScript on the account.
volume:
type: array
items:
$ref: '#/components/schemas/Grant'
description: >
The grants this user has pertaining to Volumes on this account.
There will be one entry per Volume on the account.
Raw
model.json
{
"name": "Linode API V4",
"types": [
{
"name": "Account",
"description": "implements the service definition of Account",
"fields": [
{
"name": "address_1",
"type": "string",
"nativeType": "string",
"fieldName": "Address1",
"parameterName": "address_1",
"serialize": true
},
{
"name": "address_2",
"type": "string",
"nativeType": "string",
"fieldName": "Address2",
"parameterName": "address_2",
"serialize": true
},
{
"name": "balance",
"type": "number",
"nativeType": "int",
"fieldName": "Balance",
"parameterName": "balance",
"serialize": true
},
{
"name": "city",
"type": "string",
"nativeType": "string",
"fieldName": "City",
"parameterName": "city",
"serialize": true
},
{
"name": "company",
"type": "string",
"nativeType": "string",
"fieldName": "Company",
"parameterName": "company",
"serialize": true
},
{
"name": "country",
"type": "string",
"nativeType": "string",
"fieldName": "Country",
"parameterName": "country",
"serialize": true
},
{
"name": "email",
"type": "string",
"nativeType": "string",
"fieldName": "Email",
"parameterName": "email",
"serialize": true
},
{
"name": "first_name",
"type": "string",
"nativeType": "string",
"fieldName": "FirstName",
"parameterName": "first_name",
"serialize": true
},
{
"name": "last_name",
"type": "string",
"nativeType": "string",
"fieldName": "LastName",
"parameterName": "last_name",
"serialize": true
},
{
"name": "phone",
"type": "string",
"nativeType": "string",
"fieldName": "Phone",
"parameterName": "phone",
"serialize": true
},
{
"name": "state",
"type": "string",
"nativeType": "string",
"fieldName": "State",
"parameterName": "state",
"serialize": true
},
{
"name": "tax_id",
"type": "string",
"nativeType": "string",
"fieldName": "TaxId",
"parameterName": "tax_id",
"serialize": true
},
{
"name": "zip",
"type": "string",
"nativeType": "string",
"fieldName": "Zip",
"parameterName": "zip",
"serialize": true
}
],
"typeName": "Account"
},
{
"name": "AccountSettings",
"description": "implements the service definition of AccountSettings",
"fields": [
{
"name": "managed",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Managed",
"parameterName": "managed",
"serialize": true
},
{
"name": "longview_subscription",
"type": "string",
"nativeType": "string",
"fieldName": "LongviewSubscription",
"parameterName": "longview_subscription",
"serialize": true
},
{
"name": "network_helper",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "NetworkHelper",
"parameterName": "network_helper",
"serialize": true
}
],
"typeName": "AccountSettings"
},
{
"name": "Backup",
"description": "implements the service definition of Backup",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
},
{
"name": "finished",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Finished",
"parameterName": "finished",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "configs",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "Configs",
"parameterName": "configs",
"serialize": true
},
{
"name": "disks",
"type": "interface{}",
"kind": 2,
"nativeType": "Interface{}",
"fieldName": "Disks",
"parameterName": "disks",
"serialize": true
}
],
"typeName": "Backup"
},
{
"name": "CreditCard",
"description": "implements the service definition of CreditCard",
"fields": [
{
"name": "card_number",
"type": "string",
"nativeType": "string",
"fieldName": "CardNumber",
"parameterName": "card_number",
"serialize": true
},
{
"name": "expiry_month",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "ExpiryMonth",
"parameterName": "expiry_month",
"serialize": true
},
{
"name": "expiry_year",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "ExpiryYear",
"parameterName": "expiry_year",
"serialize": true
}
],
"typeName": "CreditCard"
},
{
"name": "ErrorObject",
"description": "implements the service definition of ErrorObject",
"fields": [
{
"name": "reason",
"type": "string",
"nativeType": "string",
"fieldName": "Reason",
"parameterName": "reason",
"serialize": true
},
{
"name": "field",
"type": "string",
"nativeType": "string",
"fieldName": "Field",
"parameterName": "field",
"serialize": true
}
],
"typeName": "ErrorObject"
},
{
"name": "Event",
"description": "implements the service definition of Event",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "action",
"type": "string",
"nativeType": "string",
"fieldName": "Action",
"parameterName": "action",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "entity",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Entity",
"parameterName": "entity",
"serialize": true
},
{
"name": "percent_complete",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "PercentComplete",
"parameterName": "percent_complete",
"serialize": true
},
{
"name": "rate",
"type": "string",
"nativeType": "string",
"fieldName": "Rate",
"parameterName": "rate",
"serialize": true
},
{
"name": "read",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Read",
"parameterName": "read",
"serialize": true
},
{
"name": "seen",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Seen",
"parameterName": "seen",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "time_remaining",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "TimeRemaining",
"parameterName": "time_remaining",
"serialize": true
},
{
"name": "username",
"type": "string",
"nativeType": "string",
"fieldName": "Username",
"parameterName": "username",
"serialize": true
}
],
"typeName": "Event"
},
{
"name": "ImagePublic",
"description": "implements the service definition of ImagePublic",
"fields": [
{
"name": "id",
"type": "string",
"nativeType": "string",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "created_by",
"type": "string",
"nativeType": "string",
"fieldName": "CreatedBy",
"parameterName": "created_by",
"serialize": true
},
{
"name": "deprecated",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Deprecated",
"parameterName": "deprecated",
"serialize": true
},
{
"name": "description",
"type": "string",
"nativeType": "string",
"fieldName": "Description",
"parameterName": "description",
"serialize": true
},
{
"name": "is_public",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "IsPublic",
"parameterName": "is_public",
"serialize": true
},
{
"name": "size",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Size",
"parameterName": "size",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "vendor",
"type": "string",
"nativeType": "string",
"fieldName": "Vendor",
"parameterName": "vendor",
"serialize": true
}
],
"typeName": "ImagePublic"
},
{
"name": "ImagePrivate",
"description": "implements the service definition of ImagePrivate",
"fields": [
{
"name": "id",
"type": "string",
"nativeType": "string",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "created_by",
"type": "string",
"nativeType": "string",
"fieldName": "CreatedBy",
"parameterName": "created_by",
"serialize": true
},
{
"name": "deprecated",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Deprecated",
"parameterName": "deprecated",
"serialize": true
},
{
"name": "description",
"type": "string",
"nativeType": "string",
"fieldName": "Description",
"parameterName": "description",
"serialize": true
},
{
"name": "is_public",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "IsPublic",
"parameterName": "is_public",
"serialize": true
},
{
"name": "size",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Size",
"parameterName": "size",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "vendor",
"type": "string",
"nativeType": "string",
"fieldName": "Vendor",
"parameterName": "vendor",
"serialize": true
}
],
"typeName": "ImagePrivate"
},
{
"name": "Invoice",
"description": "implements the service definition of Invoice",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "date",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Date",
"parameterName": "date",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "overdue",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Overdue",
"parameterName": "overdue",
"serialize": true
},
{
"name": "paid",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Paid",
"parameterName": "paid",
"serialize": true
},
{
"name": "total",
"type": "integer",
"nativeType": "int64",
"fieldName": "Total",
"parameterName": "total",
"serialize": true
}
],
"typeName": "Invoice"
},
{
"name": "InvoiceItem",
"description": "implements the service definition of InvoiceItem",
"fields": [
{
"name": "amount",
"type": "integer",
"nativeType": "int64",
"fieldName": "Amount",
"parameterName": "amount",
"serialize": true
},
{
"name": "from",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "From",
"parameterName": "from",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "quantity",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Quantity",
"parameterName": "quantity",
"serialize": true
},
{
"name": "to",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "To",
"parameterName": "to",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "unitprice",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Unitprice",
"parameterName": "unitprice",
"serialize": true
}
],
"typeName": "InvoiceItem"
},
{
"name": "Kernel",
"description": "implements the service definition of Kernel",
"fields": [
{
"name": "id",
"type": "string",
"nativeType": "string",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "version",
"type": "string",
"nativeType": "string",
"fieldName": "Version",
"parameterName": "version",
"serialize": true
},
{
"name": "kvm",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Kvm",
"parameterName": "kvm",
"serialize": true
},
{
"name": "xen",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Xen",
"parameterName": "xen",
"serialize": true
},
{
"name": "architecture",
"type": "string",
"nativeType": "string",
"fieldName": "Architecture",
"parameterName": "architecture",
"serialize": true
},
{
"name": "pvops",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Pvops",
"parameterName": "pvops",
"serialize": true
}
],
"typeName": "Kernel"
},
{
"name": "LinodeBase",
"description": "implements the service definition of LinodeBase",
"fields": [
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "type",
"type": "id",
"nativeType": "Id",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "region",
"type": "id",
"nativeType": "Id",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
},
{
"name": "group",
"type": "string",
"nativeType": "string",
"fieldName": "Group",
"parameterName": "group",
"serialize": true
}
],
"typeName": "LinodeBase"
},
{
"name": "LinodeRequest",
"description": "implements the service definition of LinodeRequest",
"fields": [
{
"name": "image",
"type": "image",
"nativeType": "Image",
"fieldName": "Image",
"parameterName": "image",
"serialize": true
},
{
"name": "root_pass",
"type": "root_pass",
"nativeType": "Root_pass",
"fieldName": "RootPass",
"parameterName": "root_pass",
"serialize": true
},
{
"name": "authorized_keys",
"type": "authorized_keys",
"nativeType": "Authorized_keys",
"fieldName": "AuthorizedKeys",
"parameterName": "authorized_keys",
"serialize": true
},
{
"name": "stackscript_id",
"type": "stackscript_id",
"nativeType": "Stackscript_id",
"fieldName": "StackscriptId",
"parameterName": "stackscript_id",
"serialize": true
},
{
"name": "stackscript_data",
"type": "stackscript_data",
"nativeType": "Stackscript_data",
"fieldName": "StackscriptData",
"parameterName": "stackscript_data",
"serialize": true
},
{
"name": "booted",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Booted",
"parameterName": "booted",
"serialize": true
}
],
"typeName": "LinodeRequest"
},
{
"name": "LinodeStats",
"description": "implements the service definition of LinodeStats",
"fields": [
{
"name": "cpu",
"type": "unimplemented: example:\u003cyaml:\"- 1521483600000\\n- 0.42\\n\" \u003e type:\"array\" items:\u003cschema:\u003ctype:\"number\" \u003e \u003e description:\"Percentage of CPU used.\\n\" ",
"nativeType": "Unimplemented: Example:\u003cYaml:\"- 1521483600000\\N- 0.42\\N\" \u003e Type:\"Array\" Items:\u003cSchema:\u003cType:\"Number\" \u003e \u003e Description:\"Percentage Of CPU Used.\\N\" ",
"fieldName": "Cpu",
"parameterName": "cpu",
"serialize": true
},
{
"name": "io",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Io",
"parameterName": "io",
"serialize": true
},
{
"name": "netv4",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Netv4",
"parameterName": "netv4",
"serialize": true
},
{
"name": "netv6",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Netv6",
"parameterName": "netv6",
"serialize": true
},
{
"name": "title",
"type": "string",
"nativeType": "string",
"fieldName": "Title",
"parameterName": "title",
"serialize": true
}
],
"typeName": "LinodeStats"
},
{
"name": "LinodeType",
"description": "implements the service definition of LinodeType",
"fields": [
{
"name": "id",
"type": "string",
"nativeType": "string",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "disk",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Disk",
"parameterName": "disk",
"serialize": true
},
{
"name": "class",
"type": "string",
"nativeType": "string",
"fieldName": "Class",
"parameterName": "class",
"serialize": true
},
{
"name": "price",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Price",
"parameterName": "price",
"serialize": true
},
{
"name": "addons",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Addons",
"parameterName": "addons",
"serialize": true
},
{
"name": "network_out",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "NetworkOut",
"parameterName": "network_out",
"serialize": true
},
{
"name": "memory",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Memory",
"parameterName": "memory",
"serialize": true
},
{
"name": "transfer",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Transfer",
"parameterName": "transfer",
"serialize": true
},
{
"name": "vcpus",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Vcpus",
"parameterName": "vcpus",
"serialize": true
}
],
"typeName": "LinodeType"
},
{
"name": "LinodeConfig",
"description": "implements the service definition of LinodeConfig",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "kernel",
"type": "string",
"nativeType": "string",
"fieldName": "Kernel",
"parameterName": "kernel",
"serialize": true
},
{
"name": "comments",
"type": "string",
"nativeType": "string",
"fieldName": "Comments",
"parameterName": "comments",
"serialize": true
},
{
"name": "memory_limit",
"type": "integer",
"nativeType": "int64",
"fieldName": "MemoryLimit",
"parameterName": "memory_limit",
"serialize": true
},
{
"name": "root_device_ro",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "RootDeviceRo",
"parameterName": "root_device_ro",
"serialize": true
},
{
"name": "run_level",
"type": "string",
"nativeType": "string",
"fieldName": "RunLevel",
"parameterName": "run_level",
"serialize": true
},
{
"name": "virt_mode",
"type": "string",
"nativeType": "string",
"fieldName": "VirtMode",
"parameterName": "virt_mode",
"serialize": true
},
{
"name": "helpers",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Helpers",
"parameterName": "helpers",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "devices",
"type": "Devices",
"nativeType": "Devices",
"fieldName": "Devices",
"parameterName": "devices",
"serialize": true
}
],
"typeName": "LinodeConfig"
},
{
"name": "Disk",
"description": "implements the service definition of Disk",
"fields": [
{
"name": "id",
"type": "integer",
"nativeType": "int64",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "size",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Size",
"parameterName": "size",
"serialize": true
},
{
"name": "filesystem",
"type": "string",
"nativeType": "string",
"fieldName": "Filesystem",
"parameterName": "filesystem",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
}
],
"typeName": "Disk"
},
{
"name": "DiskRequest",
"description": "implements the service definition of DiskRequest",
"fields": [
{
"name": "size",
"type": "size",
"nativeType": "Size",
"fieldName": "Size",
"parameterName": "size",
"serialize": true
},
{
"name": "label",
"type": "label",
"nativeType": "Label",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "filesystem",
"type": "filesystem",
"nativeType": "Filesystem",
"fieldName": "Filesystem",
"parameterName": "filesystem",
"serialize": true
},
{
"name": "read_only",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "ReadOnly",
"parameterName": "read_only",
"serialize": true
},
{
"name": "image",
"type": "string",
"nativeType": "string",
"fieldName": "Image",
"parameterName": "image",
"serialize": true
},
{
"name": "authorized_keys",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "AuthorizedKeys",
"parameterName": "authorized_keys",
"serialize": true
},
{
"name": "root_pass",
"type": "string",
"format": "password",
"nativeType": "string",
"fieldName": "RootPass",
"parameterName": "root_pass",
"serialize": true
},
{
"name": "stackscript_id",
"type": "integer",
"nativeType": "int64",
"fieldName": "StackscriptId",
"parameterName": "stackscript_id",
"serialize": true
},
{
"name": "stackscript_data",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "StackscriptData",
"parameterName": "stackscript_data",
"serialize": true
}
],
"typeName": "DiskRequest"
},
{
"name": "Device",
"description": "implements the service definition of Device",
"fields": [
{
"name": "disk_id",
"type": "integer",
"nativeType": "int64",
"fieldName": "DiskId",
"parameterName": "disk_id",
"serialize": true
},
{
"name": "volume_id",
"type": "integer",
"nativeType": "int64",
"fieldName": "VolumeId",
"parameterName": "volume_id",
"serialize": true
}
],
"typeName": "Device"
},
{
"name": "Domain",
"description": "implements the service definition of Domain",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "domain",
"type": "string",
"nativeType": "string",
"fieldName": "Domain",
"parameterName": "domain",
"serialize": true
},
{
"name": "group",
"type": "string",
"nativeType": "string",
"fieldName": "Group",
"parameterName": "group",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "description",
"type": "string",
"nativeType": "string",
"fieldName": "Description",
"parameterName": "description",
"serialize": true
},
{
"name": "soa_email",
"type": "string",
"format": "email",
"nativeType": "string",
"fieldName": "SoaEmail",
"parameterName": "soa_email",
"serialize": true
},
{
"name": "retry_sec",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "RetrySec",
"parameterName": "retry_sec",
"serialize": true
},
{
"name": "master_ips",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "MasterIps",
"parameterName": "master_ips",
"serialize": true
},
{
"name": "axfr_ips",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "AxfrIps",
"parameterName": "axfr_ips",
"serialize": true
},
{
"name": "expire_sec",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "ExpireSec",
"parameterName": "expire_sec",
"serialize": true
},
{
"name": "refresh_sec",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "RefreshSec",
"parameterName": "refresh_sec",
"serialize": true
},
{
"name": "ttl_sec",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "TtlSec",
"parameterName": "ttl_sec",
"serialize": true
}
],
"typeName": "Domain"
},
{
"name": "DomainRecord",
"description": "implements the service definition of DomainRecord",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "name",
"type": "string",
"nativeType": "string",
"fieldName": "Name",
"parameterName": "name",
"serialize": true
},
{
"name": "target",
"type": "string",
"nativeType": "string",
"fieldName": "Target",
"parameterName": "target",
"serialize": true
},
{
"name": "priority",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Priority",
"parameterName": "priority",
"serialize": true
},
{
"name": "weight",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Weight",
"parameterName": "weight",
"serialize": true
},
{
"name": "port",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Port",
"parameterName": "port",
"serialize": true
},
{
"name": "service",
"type": "string",
"nativeType": "string",
"fieldName": "Service",
"parameterName": "service",
"serialize": true
},
{
"name": "protocol",
"type": "string",
"nativeType": "string",
"fieldName": "Protocol",
"parameterName": "protocol",
"serialize": true
},
{
"name": "ttl_sec",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "TtlSec",
"parameterName": "ttl_sec",
"serialize": true
},
{
"name": "tag",
"type": "string",
"nativeType": "string",
"fieldName": "Tag",
"parameterName": "tag",
"serialize": true
}
],
"typeName": "DomainRecord"
},
{
"name": "IPAddress",
"description": "implements the service definition of IPAddress",
"fields": [
{
"name": "address",
"type": "string",
"format": "ip",
"nativeType": "string",
"fieldName": "Address",
"parameterName": "address",
"serialize": true
},
{
"name": "gateway",
"type": "string",
"format": "ip",
"nativeType": "string",
"fieldName": "Gateway",
"parameterName": "gateway",
"serialize": true
},
{
"name": "subnet_mask",
"type": "string",
"format": "ip",
"nativeType": "string",
"fieldName": "SubnetMask",
"parameterName": "subnet_mask",
"serialize": true
},
{
"name": "prefix",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Prefix",
"parameterName": "prefix",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "rdns",
"type": "string",
"nativeType": "string",
"fieldName": "Rdns",
"parameterName": "rdns",
"serialize": true
},
{
"name": "linode_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "LinodeId",
"parameterName": "linode_id",
"serialize": true
},
{
"name": "region",
"type": "string",
"nativeType": "string",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
}
],
"typeName": "IPAddress"
},
{
"name": "IPv6Pool",
"description": "implements the service definition of IPv6Pool",
"fields": [
{
"name": "range",
"type": "string",
"nativeType": "string",
"fieldName": "Range",
"parameterName": "range",
"serialize": true
},
{
"name": "region",
"type": "string",
"nativeType": "string",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
}
],
"typeName": "IPv6Pool"
},
{
"name": "IPv6Range",
"description": "implements the service definition of IPv6Range",
"fields": [
{
"name": "range",
"type": "string",
"nativeType": "string",
"fieldName": "Range",
"parameterName": "range",
"serialize": true
},
{
"name": "region",
"type": "string",
"nativeType": "string",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
}
],
"typeName": "IPv6Range"
},
{
"name": "NodeBalancer",
"description": "implements the service definition of NodeBalancer",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "region",
"type": "string",
"nativeType": "string",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
},
{
"name": "hostname",
"type": "string",
"nativeType": "string",
"fieldName": "Hostname",
"parameterName": "hostname",
"serialize": true
},
{
"name": "ipv4",
"type": "string",
"format": "ip",
"nativeType": "string",
"fieldName": "Ipv4",
"parameterName": "ipv4",
"serialize": true
},
{
"name": "ipv6",
"type": "string",
"format": "ip",
"nativeType": "string",
"fieldName": "Ipv6",
"parameterName": "ipv6",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
},
{
"name": "client_conn_throttle",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "ClientConnThrottle",
"parameterName": "client_conn_throttle",
"serialize": true
}
],
"typeName": "NodeBalancer"
},
{
"name": "NodeBalancerConfig",
"description": "implements the service definition of NodeBalancerConfig",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "port",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Port",
"parameterName": "port",
"serialize": true
},
{
"name": "protocol",
"type": "string",
"nativeType": "string",
"fieldName": "Protocol",
"parameterName": "protocol",
"serialize": true
},
{
"name": "algorithm",
"type": "string",
"nativeType": "string",
"fieldName": "Algorithm",
"parameterName": "algorithm",
"serialize": true
},
{
"name": "stickiness",
"type": "string",
"nativeType": "string",
"fieldName": "Stickiness",
"parameterName": "stickiness",
"serialize": true
},
{
"name": "check",
"type": "string",
"nativeType": "string",
"fieldName": "Check",
"parameterName": "check",
"serialize": true
},
{
"name": "check_interval",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "CheckInterval",
"parameterName": "check_interval",
"serialize": true
},
{
"name": "check_timeout",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "CheckTimeout",
"parameterName": "check_timeout",
"serialize": true
},
{
"name": "check_attempts",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "CheckAttempts",
"parameterName": "check_attempts",
"serialize": true
},
{
"name": "check_path",
"type": "string",
"nativeType": "string",
"fieldName": "CheckPath",
"parameterName": "check_path",
"serialize": true
},
{
"name": "check_body",
"type": "string",
"nativeType": "string",
"fieldName": "CheckBody",
"parameterName": "check_body",
"serialize": true
},
{
"name": "check_passive",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "CheckPassive",
"parameterName": "check_passive",
"serialize": true
},
{
"name": "cipher_suite",
"type": "string",
"nativeType": "string",
"fieldName": "CipherSuite",
"parameterName": "cipher_suite",
"serialize": true
},
{
"name": "nodebalancer_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "NodebalancerId",
"parameterName": "nodebalancer_id",
"serialize": true
},
{
"name": "ssl_commonname",
"type": "string",
"nativeType": "string",
"fieldName": "SslCommonname",
"parameterName": "ssl_commonname",
"serialize": true
},
{
"name": "ssl_fingerprint",
"type": "string",
"nativeType": "string",
"fieldName": "SslFingerprint",
"parameterName": "ssl_fingerprint",
"serialize": true
},
{
"name": "ssl_cert",
"type": "string",
"nativeType": "string",
"fieldName": "SslCert",
"parameterName": "ssl_cert",
"serialize": true
},
{
"name": "ssl_key",
"type": "string",
"nativeType": "string",
"fieldName": "SslKey",
"parameterName": "ssl_key",
"serialize": true
},
{
"name": "node_status",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "NodeStatus",
"parameterName": "node_status",
"serialize": true
}
],
"typeName": "NodeBalancerConfig"
},
{
"name": "NodeBalancerNode",
"description": "implements the service definition of NodeBalancerNode",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "address",
"type": "string",
"format": "ip",
"nativeType": "string",
"fieldName": "Address",
"parameterName": "address",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "weight",
"type": "integer",
"nativeType": "int64",
"fieldName": "Weight",
"parameterName": "weight",
"serialize": true
},
{
"name": "mode",
"type": "string",
"nativeType": "string",
"fieldName": "Mode",
"parameterName": "mode",
"serialize": true
},
{
"name": "config_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "ConfigId",
"parameterName": "config_id",
"serialize": true
},
{
"name": "nodebalancer_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "NodebalancerId",
"parameterName": "nodebalancer_id",
"serialize": true
}
],
"typeName": "NodeBalancerNode"
},
{
"name": "Notification",
"description": "implements the service definition of Notification",
"fields": [
{
"name": "entity",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Entity",
"parameterName": "entity",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "message",
"type": "string",
"nativeType": "string",
"fieldName": "Message",
"parameterName": "message",
"serialize": true
},
{
"name": "type",
"type": "string",
"nativeType": "string",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "severity",
"type": "string",
"nativeType": "string",
"fieldName": "Severity",
"parameterName": "severity",
"serialize": true
},
{
"name": "when",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "When",
"parameterName": "when",
"serialize": true
},
{
"name": "until",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Until",
"parameterName": "until",
"serialize": true
}
],
"typeName": "Notification"
},
{
"name": "OAuthClient",
"description": "implements the service definition of OAuthClient",
"fields": [
{
"name": "id",
"type": "string",
"nativeType": "string",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "redirect_uri",
"type": "string",
"format": "url",
"nativeType": "string",
"fieldName": "RedirectUri",
"parameterName": "redirect_uri",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "secret",
"type": "string",
"nativeType": "string",
"fieldName": "Secret",
"parameterName": "secret",
"serialize": true
},
{
"name": "thumbnail_url",
"type": "string",
"format": "url",
"nativeType": "string",
"fieldName": "ThumbnailUrl",
"parameterName": "thumbnail_url",
"serialize": true
},
{
"name": "public",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Public",
"parameterName": "public",
"serialize": true
}
],
"typeName": "OAuthClient"
},
{
"name": "PaginationEnvelope",
"description": "implements the service definition of PaginationEnvelope",
"fields": [
{
"name": "data",
"type": "interface{}",
"kind": 2,
"nativeType": "Interface{}",
"fieldName": "Data",
"parameterName": "data",
"serialize": true
},
{
"name": "pages",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Pages",
"parameterName": "pages",
"serialize": true
},
{
"name": "page",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Page",
"parameterName": "page",
"serialize": true
},
{
"name": "results",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Results",
"parameterName": "results",
"serialize": true
}
],
"typeName": "PaginationEnvelope"
},
{
"name": "RescueDevices",
"description": "implements the service definition of RescueDevices",
"fields": [
{
"name": "sda",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sda",
"parameterName": "sda",
"serialize": true
},
{
"name": "sdb",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sdb",
"parameterName": "sdb",
"serialize": true
},
{
"name": "sdc",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sdc",
"parameterName": "sdc",
"serialize": true
},
{
"name": "sdd",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sdd",
"parameterName": "sdd",
"serialize": true
},
{
"name": "sde",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sde",
"parameterName": "sde",
"serialize": true
},
{
"name": "sdf",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sdf",
"parameterName": "sdf",
"serialize": true
},
{
"name": "sdg",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sdg",
"parameterName": "sdg",
"serialize": true
}
],
"typeName": "RescueDevices"
},
{
"name": "Devices",
"description": "implements the service definition of Devices",
"fields": [
{
"name": "sdh",
"type": "Device",
"nativeType": "Device",
"fieldName": "Sdh",
"parameterName": "sdh",
"serialize": true
}
],
"typeName": "Devices"
},
{
"name": "Linode",
"description": "implements the service definition of Linode",
"fields": [
{
"name": "label",
"type": "unimplemented: specification_extension:\u003cname:\"x-linode-filterable\" value:\u003cyaml:\"true\\n\" \u003e \u003e ",
"nativeType": "Unimplemented: Specification_extension:\u003cName:\"X-Linode-Filterable\" Value:\u003cYaml:\"True\\N\" \u003e \u003e ",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "region",
"type": "unimplemented: read_only:true description:\"This is the location where the Linode was deployed. This cannot be changed without opening a support ticket.\\n\" specification_extension:\u003cname:\"x-linode-filterable\" value:\u003cyaml:\"true\\n\" \u003e \u003e ",
"nativeType": "Unimplemented: Read_only:True Description:\"This Is The Location Where The Linode Was Deployed. This Cannot Be Changed Without Opening A Support Ticket.\\N\" Specification_extension:\u003cName:\"X-Linode-Filterable\" Value:\u003cYaml:\"True\\N\" \u003e \u003e ",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
},
{
"name": "image",
"type": "unimplemented: read_only:true all_of:\u003creference:\u003c_ref:\"#/components/schemas/DiskRequest/properties/image\" \u003e \u003e specification_extension:\u003cname:\"x-linode-filterable\" value:\u003cyaml:\"true\\n\" \u003e \u003e ",
"nativeType": "Unimplemented: Read_only:True All_of:\u003cReference:\u003c_ref:\"#/Components/Schemas/DiskRequest/Properties/Image\" \u003e \u003e Specification_extension:\u003cName:\"X-Linode-Filterable\" Value:\u003cYaml:\"True\\N\" \u003e \u003e ",
"fieldName": "Image",
"parameterName": "image",
"serialize": true
},
{
"name": "type",
"type": "unimplemented: read_only:true description:\"This is the Linode service plan type that this Linode was deployed with.\\nTo change a Linode's type, use `POST /linode/instances/{linodeId}/resize`.\\n\" ",
"nativeType": "Unimplemented: Read_only:True Description:\"This Is The Linode Service Plan Type That This Linode Was Deployed With.\\NTo Change A Linode'S Type, Use `POST /Linode/Instances/{LinodeId}/Resize`.\\N\" ",
"fieldName": "Type",
"parameterName": "myType",
"serialize": true
},
{
"name": "group",
"type": "unimplemented: specification_extension:\u003cname:\"x-linode-filterable\" value:\u003cyaml:\"true\\n\" \u003e \u003e ",
"nativeType": "Unimplemented: Specification_extension:\u003cName:\"X-Linode-Filterable\" Value:\u003cYaml:\"True\\N\" \u003e \u003e ",
"fieldName": "Group",
"parameterName": "group",
"serialize": true
},
{
"name": "id",
"type": "integer",
"nativeType": "int64",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "hypervisor",
"type": "string",
"nativeType": "string",
"fieldName": "Hypervisor",
"parameterName": "hypervisor",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
},
{
"name": "ipv4",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "Ipv4",
"parameterName": "ipv4",
"serialize": true
},
{
"name": "ipv6",
"type": "string",
"nativeType": "string",
"fieldName": "Ipv6",
"parameterName": "ipv6",
"serialize": true
},
{
"name": "specs",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Specs",
"parameterName": "specs",
"serialize": true
},
{
"name": "alerts",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Alerts",
"parameterName": "alerts",
"serialize": true
},
{
"name": "backups",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Backups",
"parameterName": "backups",
"serialize": true
}
],
"typeName": "Linode"
},
{
"name": "Region",
"description": "implements the service definition of Region",
"fields": [
{
"name": "id",
"type": "string",
"nativeType": "string",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "country",
"type": "string",
"nativeType": "string",
"fieldName": "Country",
"parameterName": "country",
"serialize": true
}
],
"typeName": "Region"
},
{
"name": "LongviewClient",
"description": "implements the service definition of LongviewClient",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "api_key",
"type": "string",
"nativeType": "string",
"fieldName": "ApiKey",
"parameterName": "api_key",
"serialize": true
},
{
"name": "install_code",
"type": "string",
"nativeType": "string",
"fieldName": "InstallCode",
"parameterName": "install_code",
"serialize": true
},
{
"name": "apps",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Apps",
"parameterName": "apps",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
}
],
"typeName": "LongviewClient"
},
{
"name": "LongviewSubscription",
"description": "implements the service definition of LongviewSubscription",
"fields": [
{
"name": "id",
"type": "string",
"nativeType": "string",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "price",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Price",
"parameterName": "price",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "clients_included",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "ClientsIncluded",
"parameterName": "clients_included",
"serialize": true
}
],
"typeName": "LongviewSubscription"
},
{
"name": "ManagedContact",
"description": "implements the service definition of ManagedContact",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "name",
"type": "string",
"nativeType": "string",
"fieldName": "Name",
"parameterName": "name",
"serialize": true
},
{
"name": "email",
"type": "string",
"format": "email",
"nativeType": "string",
"fieldName": "Email",
"parameterName": "email",
"serialize": true
},
{
"name": "phone",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Phone",
"parameterName": "phone",
"serialize": true
},
{
"name": "group",
"type": "string",
"nativeType": "string",
"fieldName": "Group",
"parameterName": "group",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
}
],
"typeName": "ManagedContact"
},
{
"name": "ManagedCredential",
"description": "implements the service definition of ManagedCredential",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
}
],
"typeName": "ManagedCredential"
},
{
"name": "ManagedIssue",
"description": "implements the service definition of ManagedIssue",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "services",
"type": "unimplemented: read_only:true type:\"array\" items:\u003cschema:\u003cexample:\u003cyaml:\"654\\n\" \u003e type:\"integer\" format:\"int32\" \u003e \u003e description:\"An array of Managed Service IDs that were affected by this issue.\\n\" ",
"nativeType": "Unimplemented: Read_only:True Type:\"Array\" Items:\u003cSchema:\u003cExample:\u003cYaml:\"654\\N\" \u003e Type:\"Integer\" Format:\"Int32\" \u003e \u003e Description:\"An Array Of Managed Service IDs That Were Affected By This Issue.\\N\" ",
"fieldName": "Services",
"parameterName": "services",
"serialize": true
},
{
"name": "entity",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Entity",
"parameterName": "entity",
"serialize": true
}
],
"typeName": "ManagedIssue"
},
{
"name": "ManagedLinodeSettings",
"description": "implements the service definition of ManagedLinodeSettings",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "group",
"type": "string",
"nativeType": "string",
"fieldName": "Group",
"parameterName": "group",
"serialize": true
},
{
"name": "ssh",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Ssh",
"parameterName": "ssh",
"serialize": true
}
],
"typeName": "ManagedLinodeSettings"
},
{
"name": "ManagedService",
"description": "implements the service definition of ManagedService",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "service_type",
"type": "string",
"nativeType": "string",
"fieldName": "ServiceType",
"parameterName": "service_type",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "address",
"type": "string",
"format": "url",
"nativeType": "string",
"fieldName": "Address",
"parameterName": "address",
"serialize": true
},
{
"name": "timeout",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Timeout",
"parameterName": "timeout",
"serialize": true
},
{
"name": "body",
"type": "string",
"nativeType": "string",
"fieldName": "Body",
"parameterName": "body",
"serialize": true
},
{
"name": "consultation_group",
"type": "string",
"nativeType": "string",
"fieldName": "ConsultationGroup",
"parameterName": "consultation_group",
"serialize": true
},
{
"name": "notes",
"type": "string",
"nativeType": "string",
"fieldName": "Notes",
"parameterName": "notes",
"serialize": true
},
{
"name": "region",
"type": "string",
"nativeType": "string",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
},
{
"name": "credentials",
"type": "unimplemented: type:\"array\" items:\u003cschema:\u003cexample:\u003cyaml:\"9991\\n\" \u003e type:\"integer\" format:\"int32\" \u003e \u003e description:\"An array of ManagedCredential ids that should be used when attempting to resolve issues with this service.\\n\" ",
"nativeType": "Unimplemented: Type:\"Array\" Items:\u003cSchema:\u003cExample:\u003cYaml:\"9991\\N\" \u003e Type:\"Integer\" Format:\"Int32\" \u003e \u003e Description:\"An Array Of ManagedCredential Ids That Should Be Used When Attempting To Resolve Issues With This Service.\\N\" ",
"fieldName": "Credentials",
"parameterName": "credentials",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
}
],
"typeName": "ManagedService"
},
{
"name": "StackScript",
"description": "implements the service definition of StackScript",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "username",
"type": "string",
"nativeType": "string",
"fieldName": "Username",
"parameterName": "username",
"serialize": true
},
{
"name": "user_gravatar_id",
"type": "string",
"nativeType": "string",
"fieldName": "UserGravatarId",
"parameterName": "user_gravatar_id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "description",
"type": "string",
"nativeType": "string",
"fieldName": "Description",
"parameterName": "description",
"serialize": true
},
{
"name": "images",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "Images",
"parameterName": "images",
"serialize": true
},
{
"name": "deployments_total",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "DeploymentsTotal",
"parameterName": "deployments_total",
"serialize": true
},
{
"name": "deployments_active",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "DeploymentsActive",
"parameterName": "deployments_active",
"serialize": true
},
{
"name": "is_public",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "IsPublic",
"parameterName": "is_public",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
},
{
"name": "rev_note",
"type": "string",
"nativeType": "string",
"fieldName": "RevNote",
"parameterName": "rev_note",
"serialize": true
},
{
"name": "script",
"type": "string",
"nativeType": "string",
"fieldName": "Script",
"parameterName": "script",
"serialize": true
},
{
"name": "user_defined_fields",
"type": "UserDefinedField",
"kind": 2,
"nativeType": "UserDefinedField",
"fieldName": "UserDefinedFields",
"parameterName": "user_defined_fields",
"serialize": true
}
],
"typeName": "StackScript"
},
{
"name": "SupportTicket",
"description": "implements the service definition of SupportTicket",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "attachments",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "Attachments",
"parameterName": "attachments",
"serialize": true
},
{
"name": "closed",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Closed",
"parameterName": "closed",
"serialize": true
},
{
"name": "description",
"type": "string",
"nativeType": "string",
"fieldName": "Description",
"parameterName": "description",
"serialize": true
},
{
"name": "entity",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Entity",
"parameterName": "entity",
"serialize": true
},
{
"name": "gravatar_id",
"type": "string",
"nativeType": "string",
"fieldName": "GravatarId",
"parameterName": "gravatar_id",
"serialize": true
},
{
"name": "opened",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Opened",
"parameterName": "opened",
"serialize": true
},
{
"name": "opened_by",
"type": "string",
"nativeType": "string",
"fieldName": "OpenedBy",
"parameterName": "opened_by",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "summary",
"type": "string",
"nativeType": "string",
"fieldName": "Summary",
"parameterName": "summary",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
},
{
"name": "updated_by",
"type": "string",
"nativeType": "string",
"fieldName": "UpdatedBy",
"parameterName": "updated_by",
"serialize": true
}
],
"typeName": "SupportTicket"
},
{
"name": "SupportTicketReply",
"description": "implements the service definition of SupportTicketReply",
"fields": [
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "created_by",
"type": "string",
"nativeType": "string",
"fieldName": "CreatedBy",
"parameterName": "created_by",
"serialize": true
},
{
"name": "description",
"type": "string",
"nativeType": "string",
"fieldName": "Description",
"parameterName": "description",
"serialize": true
},
{
"name": "from_linode",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "FromLinode",
"parameterName": "from_linode",
"serialize": true
},
{
"name": "gravatar_id",
"type": "string",
"nativeType": "string",
"fieldName": "GravatarId",
"parameterName": "gravatar_id",
"serialize": true
},
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
}
],
"typeName": "SupportTicketReply"
},
{
"name": "SupportTicketRequest",
"description": "implements the service definition of SupportTicketRequest",
"fields": [
{
"name": "description",
"type": "string",
"nativeType": "string",
"fieldName": "Description",
"parameterName": "description",
"serialize": true
},
{
"name": "domain_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "DomainId",
"parameterName": "domain_id",
"serialize": true
},
{
"name": "linode_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "LinodeId",
"parameterName": "linode_id",
"serialize": true
},
{
"name": "longviewclient_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "LongviewclientId",
"parameterName": "longviewclient_id",
"serialize": true
},
{
"name": "nodebalancer_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "NodebalancerId",
"parameterName": "nodebalancer_id",
"serialize": true
},
{
"name": "summary",
"type": "string",
"nativeType": "string",
"fieldName": "Summary",
"parameterName": "summary",
"serialize": true
},
{
"name": "volume_id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "VolumeId",
"parameterName": "volume_id",
"serialize": true
}
],
"typeName": "SupportTicketRequest"
},
{
"name": "UserDefinedField",
"description": "implements the service definition of UserDefinedField",
"fields": [
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "name",
"type": "string",
"nativeType": "string",
"fieldName": "Name",
"parameterName": "name",
"serialize": true
},
{
"name": "example",
"type": "string",
"nativeType": "string",
"fieldName": "Example",
"parameterName": "example",
"serialize": true
},
{
"name": "oneOf",
"type": "string",
"nativeType": "string",
"fieldName": "OneOf",
"parameterName": "oneOf",
"serialize": true
},
{
"name": "manyOf",
"type": "string",
"nativeType": "string",
"fieldName": "ManyOf",
"parameterName": "manyOf",
"serialize": true
}
],
"typeName": "UserDefinedField"
},
{
"name": "User",
"description": "implements the service definition of User",
"fields": [
{
"name": "username",
"type": "string",
"nativeType": "string",
"fieldName": "Username",
"parameterName": "username",
"serialize": true
},
{
"name": "email",
"type": "string",
"format": "email",
"nativeType": "string",
"fieldName": "Email",
"parameterName": "email",
"serialize": true
},
{
"name": "restricted",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Restricted",
"parameterName": "restricted",
"serialize": true
}
],
"typeName": "User"
},
{
"name": "Volume",
"description": "implements the service definition of Volume",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "status",
"type": "string",
"nativeType": "string",
"fieldName": "Status",
"parameterName": "status",
"serialize": true
},
{
"name": "size",
"type": "integer",
"nativeType": "int64",
"fieldName": "Size",
"parameterName": "size",
"serialize": true
},
{
"name": "region",
"type": "id",
"nativeType": "Id",
"fieldName": "Region",
"parameterName": "region",
"serialize": true
},
{
"name": "linode_id",
"type": "integer",
"nativeType": "int64",
"fieldName": "LinodeId",
"parameterName": "linode_id",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "updated",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Updated",
"parameterName": "updated",
"serialize": true
}
],
"typeName": "Volume"
},
{
"name": "AuthorizedApp",
"description": "implements the service definition of AuthorizedApp",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "thumbnail_url",
"type": "string",
"format": "url",
"nativeType": "string",
"fieldName": "ThumbnailUrl",
"parameterName": "thumbnail_url",
"serialize": true
},
{
"name": "scopes",
"type": "string",
"format": "oauth-scopes",
"nativeType": "string",
"fieldName": "Scopes",
"parameterName": "scopes",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "expiry",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Expiry",
"parameterName": "expiry",
"serialize": true
},
{
"name": "website",
"type": "string",
"format": "url",
"nativeType": "string",
"fieldName": "Website",
"parameterName": "website",
"serialize": true
}
],
"typeName": "AuthorizedApp"
},
{
"name": "PaymentRequest",
"description": "implements the service definition of PaymentRequest",
"fields": [
{
"name": "cvv",
"type": "string",
"nativeType": "string",
"fieldName": "Cvv",
"parameterName": "cvv",
"serialize": true
},
{
"name": "usd",
"type": "string",
"nativeType": "string",
"fieldName": "Usd",
"parameterName": "usd",
"serialize": true
}
],
"typeName": "PaymentRequest"
},
{
"name": "Payment",
"description": "implements the service definition of Payment",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "date",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Date",
"parameterName": "date",
"serialize": true
},
{
"name": "usd",
"type": "integer",
"nativeType": "int64",
"fieldName": "Usd",
"parameterName": "usd",
"serialize": true
}
],
"typeName": "Payment"
},
{
"name": "PayPal",
"description": "implements the service definition of PayPal",
"fields": [
{
"name": "cancel_url",
"type": "string",
"nativeType": "string",
"fieldName": "CancelUrl",
"parameterName": "cancel_url",
"serialize": true
},
{
"name": "redirect_url",
"type": "string",
"nativeType": "string",
"fieldName": "RedirectUrl",
"parameterName": "redirect_url",
"serialize": true
},
{
"name": "usd",
"type": "integer",
"nativeType": "int64",
"fieldName": "Usd",
"parameterName": "usd",
"serialize": true
}
],
"typeName": "PayPal"
},
{
"name": "PayPalExecute",
"description": "implements the service definition of PayPalExecute",
"fields": [
{
"name": "payer_id",
"type": "string",
"nativeType": "string",
"fieldName": "PayerId",
"parameterName": "payer_id",
"serialize": true
},
{
"name": "payment_id",
"type": "string",
"nativeType": "string",
"fieldName": "PaymentId",
"parameterName": "payment_id",
"serialize": true
}
],
"typeName": "PayPalExecute"
},
{
"name": "PersonalAccessToken",
"description": "implements the service definition of PersonalAccessToken",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "scopes",
"type": "string",
"format": "oauth-scopes",
"nativeType": "string",
"fieldName": "Scopes",
"parameterName": "scopes",
"serialize": true
},
{
"name": "created",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Created",
"parameterName": "created",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
},
{
"name": "token",
"type": "string",
"nativeType": "string",
"fieldName": "Token",
"parameterName": "token",
"serialize": true
},
{
"name": "expiry",
"type": "string",
"format": "date-time",
"nativeType": "string",
"fieldName": "Expiry",
"parameterName": "expiry",
"serialize": true
}
],
"typeName": "PersonalAccessToken"
},
{
"name": "Profile",
"description": "implements the service definition of Profile",
"fields": [
{
"name": "uid",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Uid",
"parameterName": "uid",
"serialize": true
},
{
"name": "username",
"type": "string",
"nativeType": "string",
"fieldName": "Username",
"parameterName": "username",
"serialize": true
},
{
"name": "email",
"type": "string",
"format": "email",
"nativeType": "string",
"fieldName": "Email",
"parameterName": "email",
"serialize": true
},
{
"name": "timezone",
"type": "string",
"nativeType": "string",
"fieldName": "Timezone",
"parameterName": "timezone",
"serialize": true
},
{
"name": "email_notifications",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "EmailNotifications",
"parameterName": "email_notifications",
"serialize": true
},
{
"name": "referrals",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Referrals",
"parameterName": "referrals",
"serialize": true
},
{
"name": "ip_whitelist_enabled",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "IpWhitelistEnabled",
"parameterName": "ip_whitelist_enabled",
"serialize": true
},
{
"name": "lish_auth_method",
"type": "string",
"nativeType": "string",
"fieldName": "LishAuthMethod",
"parameterName": "lish_auth_method",
"serialize": true
},
{
"name": "authorized_keys",
"type": "string",
"kind": 2,
"nativeType": "string",
"fieldName": "AuthorizedKeys",
"parameterName": "authorized_keys",
"serialize": true
},
{
"name": "two_factor_auth",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "TwoFactorAuth",
"parameterName": "two_factor_auth",
"serialize": true
},
{
"name": "restricted",
"type": "boolean",
"nativeType": "Boolean",
"fieldName": "Restricted",
"parameterName": "restricted",
"serialize": true
}
],
"typeName": "Profile"
},
{
"name": "Transfer",
"description": "implements the service definition of Transfer",
"fields": [
{
"name": "billable",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Billable",
"parameterName": "billable",
"serialize": true
},
{
"name": "quota",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Quota",
"parameterName": "quota",
"serialize": true
},
{
"name": "used",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Used",
"parameterName": "used",
"serialize": true
}
],
"typeName": "Transfer"
},
{
"name": "Grant",
"description": "implements the service definition of Grant",
"fields": [
{
"name": "id",
"type": "integer",
"format": "int32",
"nativeType": "int32",
"fieldName": "Id",
"parameterName": "id",
"serialize": true
},
{
"name": "permissions",
"type": "string",
"nativeType": "string",
"fieldName": "Permissions",
"parameterName": "permissions",
"serialize": true
},
{
"name": "label",
"type": "string",
"nativeType": "string",
"fieldName": "Label",
"parameterName": "label",
"serialize": true
}
],
"typeName": "Grant"
},
{
"name": "GrantsResponse",
"description": "implements the service definition of GrantsResponse",
"fields": [
{
"name": "global",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Global",
"parameterName": "global",
"serialize": true
},
{
"name": "linode",
"type": "Grant",
"kind": 2,
"nativeType": "Grant",
"fieldName": "Linode",
"parameterName": "linode",
"serialize": true
},
{
"name": "domain",
"type": "Grant",
"kind": 2,
"nativeType": "Grant",
"fieldName": "Domain",
"parameterName": "domain",
"serialize": true
},
{
"name": "nodebalancer",
"type": "Grant",
"kind": 2,
"nativeType": "Grant",
"fieldName": "Nodebalancer",
"parameterName": "nodebalancer",
"serialize": true
},
{
"name": "image",
"type": "Grant",
"kind": 2,
"nativeType": "Grant",
"fieldName": "Image",
"parameterName": "image",
"serialize": true
},
{
"name": "longview",
"type": "Grant",
"kind": 2,
"nativeType": "Grant",
"fieldName": "Longview",
"parameterName": "longview",
"serialize": true
},
{
"name": "stackscript",
"type": "Grant",
"kind": 2,
"nativeType": "Grant",
"fieldName": "Stackscript",
"parameterName": "stackscript",
"serialize": true
},
{
"name": "volume",
"type": "Grant",
"kind": 2,
"nativeType": "Grant",
"fieldName": "Volume",
"parameterName": "volume",
"serialize": true
}
],
"typeName": "GrantsResponse"
},
{
"name": "GetAccountResponses",
"description": "GetAccountResponses holds responses of GetAccount",
"fields": [
{
"name": "200",
"type": "Account",
"kind": 3,
"nativeType": "Account",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetAccountResponses"
},
{
"name": "UpdateAccountParameters",
"description": "UpdateAccountParameters holds parameters to UpdateAccount",
"fields": [
{
"name": "account",
"type": "Account",
"nativeType": "Account",
"fieldName": "Account",
"parameterName": "account",
"serialize": true
}
],
"typeName": "UpdateAccountParameters"
},
{
"name": "UpdateAccountResponses",
"description": "UpdateAccountResponses holds responses of UpdateAccount",
"fields": [
{
"name": "200",
"type": "Account",
"kind": 3,
"nativeType": "Account",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateAccountResponses"
},
{
"name": "CreateCreditCardParameters",
"description": "CreateCreditCardParameters holds parameters to CreateCreditCard",
"fields": [
{
"name": "creditcard",
"type": "CreditCard",
"nativeType": "CreditCard",
"fieldName": "Creditcard",
"parameterName": "creditcard",
"serialize": true
}
],
"typeName": "CreateCreditCardParameters"
},
{
"name": "CreateCreditCardResponses",
"description": "CreateCreditCardResponses holds responses of CreateCreditCard",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateCreditCardResponses"
},
{
"name": "GetEventsResponses",
"description": "GetEventsResponses holds responses of GetEvents",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetEventsResponses"
},
{
"name": "GetEventResponses",
"description": "GetEventResponses holds responses of GetEvent",
"fields": [
{
"name": "200",
"type": "Event",
"kind": 3,
"nativeType": "Event",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetEventResponses"
},
{
"name": "EventReadResponses",
"description": "EventReadResponses holds responses of EventRead",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "EventReadResponses"
},
{
"name": "EventSeenResponses",
"description": "EventSeenResponses holds responses of EventSeen",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "EventSeenResponses"
},
{
"name": "GetInvoicesResponses",
"description": "GetInvoicesResponses holds responses of GetInvoices",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetInvoicesResponses"
},
{
"name": "GetInvoiceResponses",
"description": "GetInvoiceResponses holds responses of GetInvoice",
"fields": [
{
"name": "200",
"type": "Invoice",
"kind": 3,
"nativeType": "Invoice",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetInvoiceResponses"
},
{
"name": "GetInvoiceItemsResponses",
"description": "GetInvoiceItemsResponses holds responses of GetInvoiceItems",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetInvoiceItemsResponses"
},
{
"name": "GetNotificationsResponses",
"description": "GetNotificationsResponses holds responses of GetNotifications",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetNotificationsResponses"
},
{
"name": "GetClientsResponses",
"description": "GetClientsResponses holds responses of GetClients",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetClientsResponses"
},
{
"name": "CreateClientParameters",
"description": "CreateClientParameters holds parameters to CreateClient",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateClientParameters"
},
{
"name": "CreateClientResponses",
"description": "CreateClientResponses holds responses of CreateClient",
"fields": [
{
"name": "200",
"type": "OAuthClient",
"kind": 3,
"nativeType": "OAuthClient",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateClientResponses"
},
{
"name": "GetClientResponses",
"description": "GetClientResponses holds responses of GetClient",
"fields": [
{
"name": "200",
"type": "OAuthClient",
"kind": 3,
"nativeType": "OAuthClient",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetClientResponses"
},
{
"name": "UpdateClientParameters",
"description": "UpdateClientParameters holds parameters to UpdateClient",
"fields": [
{
"name": "oauthclient",
"type": "OAuthClient",
"nativeType": "OAuthClient",
"fieldName": "Oauthclient",
"parameterName": "oauthclient",
"serialize": true
}
],
"typeName": "UpdateClientParameters"
},
{
"name": "UpdateClientResponses",
"description": "UpdateClientResponses holds responses of UpdateClient",
"fields": [
{
"name": "200",
"type": "OAuthClient",
"kind": 3,
"nativeType": "OAuthClient",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateClientResponses"
},
{
"name": "DeleteClientResponses",
"description": "DeleteClientResponses holds responses of DeleteClient",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteClientResponses"
},
{
"name": "GetClientThumbnailResponses",
"description": "GetClientThumbnailResponses holds responses of GetClientThumbnail",
"fields": [
{
"name": "200",
"type": "string",
"kind": 3,
"format": "binary",
"nativeType": "string",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetClientThumbnailResponses"
},
{
"name": "SetClientThumbnailParameters",
"description": "SetClientThumbnailParameters holds parameters to SetClientThumbnail",
"fields": [
{
"name": "string",
"type": "string",
"format": "binary",
"nativeType": "string",
"fieldName": "String",
"parameterName": "string",
"serialize": true
}
],
"typeName": "SetClientThumbnailParameters"
},
{
"name": "SetClientThumbnailResponses",
"description": "SetClientThumbnailResponses holds responses of SetClientThumbnail",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "SetClientThumbnailResponses"
},
{
"name": "ResetClientSecretResponses",
"description": "ResetClientSecretResponses holds responses of ResetClientSecret",
"fields": [
{
"name": "200",
"type": "OAuthClient",
"kind": 3,
"nativeType": "OAuthClient",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ResetClientSecretResponses"
},
{
"name": "GetPaymentsResponses",
"description": "GetPaymentsResponses holds responses of GetPayments",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetPaymentsResponses"
},
{
"name": "CreatePaymentParameters",
"description": "CreatePaymentParameters holds parameters to CreatePayment",
"fields": [
{
"name": "paymentrequest",
"type": "PaymentRequest",
"nativeType": "PaymentRequest",
"fieldName": "Paymentrequest",
"parameterName": "paymentrequest",
"serialize": true
}
],
"typeName": "CreatePaymentParameters"
},
{
"name": "CreatePaymentResponses",
"description": "CreatePaymentResponses holds responses of CreatePayment",
"fields": [
{
"name": "200",
"type": "Payment",
"kind": 3,
"nativeType": "Payment",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreatePaymentResponses"
},
{
"name": "GetPaymentResponses",
"description": "GetPaymentResponses holds responses of GetPayment",
"fields": [
{
"name": "200",
"type": "Payment",
"kind": 3,
"nativeType": "Payment",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetPaymentResponses"
},
{
"name": "CreatePayPalPaymentParameters",
"description": "CreatePayPalPaymentParameters holds parameters to CreatePayPalPayment",
"fields": [
{
"name": "paypal",
"type": "PayPal",
"nativeType": "PayPal",
"fieldName": "Paypal",
"parameterName": "paypal",
"serialize": true
}
],
"typeName": "CreatePayPalPaymentParameters"
},
{
"name": "CreatePayPalPaymentResponses",
"description": "CreatePayPalPaymentResponses holds responses of CreatePayPalPayment",
"fields": [
{
"name": "200",
"type": "PayPalExecute",
"kind": 3,
"nativeType": "PayPalExecute",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreatePayPalPaymentResponses"
},
{
"name": "ExecutePayPalPaymentParameters",
"description": "ExecutePayPalPaymentParameters holds parameters to ExecutePayPalPayment",
"fields": [
{
"name": "paypalexecute",
"type": "PayPalExecute",
"nativeType": "PayPalExecute",
"fieldName": "Paypalexecute",
"parameterName": "paypalexecute",
"serialize": true
}
],
"typeName": "ExecutePayPalPaymentParameters"
},
{
"name": "ExecutePayPalPaymentResponses",
"description": "ExecutePayPalPaymentResponses holds responses of ExecutePayPalPayment",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ExecutePayPalPaymentResponses"
},
{
"name": "GetAccountSettingsResponses",
"description": "GetAccountSettingsResponses holds responses of GetAccountSettings",
"fields": [
{
"name": "200",
"type": "AccountSettings",
"kind": 3,
"nativeType": "AccountSettings",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetAccountSettingsResponses"
},
{
"name": "UpdateAccountSettingsParameters",
"description": "UpdateAccountSettingsParameters holds parameters to UpdateAccountSettings",
"fields": [
{
"name": "accountsettings",
"type": "AccountSettings",
"nativeType": "AccountSettings",
"fieldName": "Accountsettings",
"parameterName": "accountsettings",
"serialize": true
}
],
"typeName": "UpdateAccountSettingsParameters"
},
{
"name": "UpdateAccountSettingsResponses",
"description": "UpdateAccountSettingsResponses holds responses of UpdateAccountSettings",
"fields": [
{
"name": "200",
"type": "AccountSettings",
"kind": 3,
"nativeType": "AccountSettings",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateAccountSettingsResponses"
},
{
"name": "GetUsersResponses",
"description": "GetUsersResponses holds responses of GetUsers",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetUsersResponses"
},
{
"name": "CreateUserParameters",
"description": "CreateUserParameters holds parameters to CreateUser",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateUserParameters"
},
{
"name": "CreateUserResponses",
"description": "CreateUserResponses holds responses of CreateUser",
"fields": [
{
"name": "200",
"type": "User",
"kind": 3,
"nativeType": "User",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateUserResponses"
},
{
"name": "GetUserResponses",
"description": "GetUserResponses holds responses of GetUser",
"fields": [
{
"name": "200",
"type": "User",
"kind": 3,
"nativeType": "User",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetUserResponses"
},
{
"name": "UpdateUserParameters",
"description": "UpdateUserParameters holds parameters to UpdateUser",
"fields": [
{
"name": "user",
"type": "User",
"nativeType": "User",
"fieldName": "User",
"parameterName": "user",
"serialize": true
}
],
"typeName": "UpdateUserParameters"
},
{
"name": "UpdateUserResponses",
"description": "UpdateUserResponses holds responses of UpdateUser",
"fields": [
{
"name": "200",
"type": "User",
"kind": 3,
"nativeType": "User",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateUserResponses"
},
{
"name": "DeleteUserResponses",
"description": "DeleteUserResponses holds responses of DeleteUser",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteUserResponses"
},
{
"name": "GetUserGrantsResponses",
"description": "GetUserGrantsResponses holds responses of GetUserGrants",
"fields": [
{
"name": "200",
"type": "GrantsResponse",
"kind": 3,
"nativeType": "GrantsResponse",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetUserGrantsResponses"
},
{
"name": "UpdateUserGrantsParameters",
"description": "UpdateUserGrantsParameters holds parameters to UpdateUserGrants",
"fields": [
{
"name": "grantsresponse",
"type": "GrantsResponse",
"nativeType": "GrantsResponse",
"fieldName": "Grantsresponse",
"parameterName": "grantsresponse",
"serialize": true
}
],
"typeName": "UpdateUserGrantsParameters"
},
{
"name": "UpdateUserGrantsResponses",
"description": "UpdateUserGrantsResponses holds responses of UpdateUserGrants",
"fields": [
{
"name": "200",
"type": "GrantsResponse",
"kind": 3,
"nativeType": "GrantsResponse",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateUserGrantsResponses"
},
{
"name": "GetTransferResponses",
"description": "GetTransferResponses holds responses of GetTransfer",
"fields": [
{
"name": "200",
"type": "Transfer",
"kind": 3,
"nativeType": "Transfer",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetTransferResponses"
},
{
"name": "GetDomainsResponses",
"description": "GetDomainsResponses holds responses of GetDomains",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetDomainsResponses"
},
{
"name": "CreateDomainParameters",
"description": "CreateDomainParameters holds parameters to CreateDomain",
"fields": [
{
"name": "domain",
"type": "Domain",
"nativeType": "Domain",
"fieldName": "Domain",
"parameterName": "domain",
"serialize": true
}
],
"typeName": "CreateDomainParameters"
},
{
"name": "CreateDomainResponses",
"description": "CreateDomainResponses holds responses of CreateDomain",
"fields": [
{
"name": "200",
"type": "Domain",
"kind": 3,
"nativeType": "Domain",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateDomainResponses"
},
{
"name": "GetDomainResponses",
"description": "GetDomainResponses holds responses of GetDomain",
"fields": [
{
"name": "200",
"type": "Domain",
"kind": 3,
"nativeType": "Domain",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetDomainResponses"
},
{
"name": "UpdateDomainParameters",
"description": "UpdateDomainParameters holds parameters to UpdateDomain",
"fields": [
{
"name": "domain",
"type": "Domain",
"nativeType": "Domain",
"fieldName": "Domain",
"parameterName": "domain",
"serialize": true
}
],
"typeName": "UpdateDomainParameters"
},
{
"name": "UpdateDomainResponses",
"description": "UpdateDomainResponses holds responses of UpdateDomain",
"fields": [
{
"name": "200",
"type": "Domain",
"kind": 3,
"nativeType": "Domain",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateDomainResponses"
},
{
"name": "DeleteDomainResponses",
"description": "DeleteDomainResponses holds responses of DeleteDomain",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteDomainResponses"
},
{
"name": "GetImagesResponses",
"description": "GetImagesResponses holds responses of GetImages",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetImagesResponses"
},
{
"name": "CreateImageParameters",
"description": "CreateImageParameters holds parameters to CreateImage",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateImageParameters"
},
{
"name": "CreateImageResponses",
"description": "CreateImageResponses holds responses of CreateImage",
"fields": [
{
"name": "200",
"type": "ImagePrivate",
"kind": 3,
"nativeType": "ImagePrivate",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateImageResponses"
},
{
"name": "GetImageResponses",
"description": "GetImageResponses holds responses of GetImage",
"fields": [
{
"name": "200",
"type": "ImagePrivate",
"kind": 3,
"nativeType": "ImagePrivate",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetImageResponses"
},
{
"name": "UpdateImageParameters",
"description": "UpdateImageParameters holds parameters to UpdateImage",
"fields": [
{
"name": "imageprivate",
"type": "ImagePrivate",
"nativeType": "ImagePrivate",
"fieldName": "Imageprivate",
"parameterName": "imageprivate",
"serialize": true
}
],
"typeName": "UpdateImageParameters"
},
{
"name": "UpdateImageResponses",
"description": "UpdateImageResponses holds responses of UpdateImage",
"fields": [
{
"name": "200",
"type": "ImagePrivate",
"kind": 3,
"nativeType": "ImagePrivate",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateImageResponses"
},
{
"name": "DeleteImageResponses",
"description": "DeleteImageResponses holds responses of DeleteImage",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteImageResponses"
},
{
"name": "GetLinodeInstacesResponses",
"description": "GetLinodeInstacesResponses holds responses of GetLinodeInstaces",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeInstacesResponses"
},
{
"name": "CreateLinodeInstanceParameters",
"description": "CreateLinodeInstanceParameters holds parameters to CreateLinodeInstance",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateLinodeInstanceParameters"
},
{
"name": "CreateLinodeInstanceResponses",
"description": "CreateLinodeInstanceResponses holds responses of CreateLinodeInstance",
"fields": [
{
"name": "200",
"type": "Linode",
"kind": 3,
"nativeType": "Linode",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateLinodeInstanceResponses"
},
{
"name": "GetLinodeInstanceResponses",
"description": "GetLinodeInstanceResponses holds responses of GetLinodeInstance",
"fields": [
{
"name": "200",
"type": "Linode",
"kind": 3,
"nativeType": "Linode",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeInstanceResponses"
},
{
"name": "UpdateLinodeInstanceParameters",
"description": "UpdateLinodeInstanceParameters holds parameters to UpdateLinodeInstance",
"fields": [
{
"name": "linode",
"type": "Linode",
"nativeType": "Linode",
"fieldName": "Linode",
"parameterName": "linode",
"serialize": true
}
],
"typeName": "UpdateLinodeInstanceParameters"
},
{
"name": "UpdateLinodeInstanceResponses",
"description": "UpdateLinodeInstanceResponses holds responses of UpdateLinodeInstance",
"fields": [
{
"name": "200",
"type": "Linode",
"kind": 3,
"nativeType": "Linode",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateLinodeInstanceResponses"
},
{
"name": "DeleteLinodeInstanceResponses",
"description": "DeleteLinodeInstanceResponses holds responses of DeleteLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteLinodeInstanceResponses"
},
{
"name": "GetBackupsResponses",
"description": "GetBackupsResponses holds responses of GetBackups",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetBackupsResponses"
},
{
"name": "CreateSnapshotParameters",
"description": "CreateSnapshotParameters holds parameters to CreateSnapshot",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateSnapshotParameters"
},
{
"name": "CreateSnapshotResponses",
"description": "CreateSnapshotResponses holds responses of CreateSnapshot",
"fields": [
{
"name": "200",
"type": "Backup",
"kind": 3,
"nativeType": "Backup",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateSnapshotResponses"
},
{
"name": "CancelBackupsResponses",
"description": "CancelBackupsResponses holds responses of CancelBackups",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CancelBackupsResponses"
},
{
"name": "EnableBackupsResponses",
"description": "EnableBackupsResponses holds responses of EnableBackups",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "EnableBackupsResponses"
},
{
"name": "GetBackupResponses",
"description": "GetBackupResponses holds responses of GetBackup",
"fields": [
{
"name": "200",
"type": "Backup",
"kind": 3,
"nativeType": "Backup",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetBackupResponses"
},
{
"name": "RestoreBackupParameters",
"description": "RestoreBackupParameters holds parameters to RestoreBackup",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "RestoreBackupParameters"
},
{
"name": "RestoreBackupResponses",
"description": "RestoreBackupResponses holds responses of RestoreBackup",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "RestoreBackupResponses"
},
{
"name": "BootLinodeInstanceParameters",
"description": "BootLinodeInstanceParameters holds parameters to BootLinodeInstance",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "BootLinodeInstanceParameters"
},
{
"name": "BootLinodeInstanceResponses",
"description": "BootLinodeInstanceResponses holds responses of BootLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "BootLinodeInstanceResponses"
},
{
"name": "RebootLinodeInstanceResponses",
"description": "RebootLinodeInstanceResponses holds responses of RebootLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "RebootLinodeInstanceResponses"
},
{
"name": "ShutdownLinodeInstanceResponses",
"description": "ShutdownLinodeInstanceResponses holds responses of ShutdownLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ShutdownLinodeInstanceResponses"
},
{
"name": "MutateLinodeInstanceResponses",
"description": "MutateLinodeInstanceResponses holds responses of MutateLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "MutateLinodeInstanceResponses"
},
{
"name": "ResizeLinodeInstanceParameters",
"description": "ResizeLinodeInstanceParameters holds parameters to ResizeLinodeInstance",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "ResizeLinodeInstanceParameters"
},
{
"name": "ResizeLinodeInstanceResponses",
"description": "ResizeLinodeInstanceResponses holds responses of ResizeLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ResizeLinodeInstanceResponses"
},
{
"name": "RebuildLinodeInstanceParameters",
"description": "RebuildLinodeInstanceParameters holds parameters to RebuildLinodeInstance",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "RebuildLinodeInstanceParameters"
},
{
"name": "RebuildLinodeInstanceResponses",
"description": "RebuildLinodeInstanceResponses holds responses of RebuildLinodeInstance",
"fields": [
{
"name": "200",
"type": "Linode",
"kind": 3,
"nativeType": "Linode",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "RebuildLinodeInstanceResponses"
},
{
"name": "RescueLinodeInstanceParameters",
"description": "RescueLinodeInstanceParameters holds parameters to RescueLinodeInstance",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "RescueLinodeInstanceParameters"
},
{
"name": "RescueLinodeInstanceResponses",
"description": "RescueLinodeInstanceResponses holds responses of RescueLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "RescueLinodeInstanceResponses"
},
{
"name": "CloneLinodeInstanceParameters",
"description": "CloneLinodeInstanceParameters holds parameters to CloneLinodeInstance",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CloneLinodeInstanceParameters"
},
{
"name": "CloneLinodeInstanceResponses",
"description": "CloneLinodeInstanceResponses holds responses of CloneLinodeInstance",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CloneLinodeInstanceResponses"
},
{
"name": "GetLinodeIPsResponses",
"description": "GetLinodeIPsResponses holds responses of GetLinodeIPs",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeIPsResponses"
},
{
"name": "AddLinodeIPResponses",
"description": "AddLinodeIPResponses holds responses of AddLinodeIP",
"fields": [
{
"name": "200",
"type": "IPAddress",
"kind": 3,
"nativeType": "IPAddress",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "AddLinodeIPResponses"
},
{
"name": "GetLinodeIPResponses",
"description": "GetLinodeIPResponses holds responses of GetLinodeIP",
"fields": [
{
"name": "200",
"type": "IPAddress",
"kind": 3,
"nativeType": "IPAddress",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeIPResponses"
},
{
"name": "UpdateLinodeIPParameters",
"description": "UpdateLinodeIPParameters holds parameters to UpdateLinodeIP",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "UpdateLinodeIPParameters"
},
{
"name": "UpdateLinodeIPResponses",
"description": "UpdateLinodeIPResponses holds responses of UpdateLinodeIP",
"fields": [
{
"name": "200",
"type": "IPAddress",
"kind": 3,
"nativeType": "IPAddress",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateLinodeIPResponses"
},
{
"name": "RemoveLinodeIPResponses",
"description": "RemoveLinodeIPResponses holds responses of RemoveLinodeIP",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "RemoveLinodeIPResponses"
},
{
"name": "GetLinodeVolumesResponses",
"description": "GetLinodeVolumesResponses holds responses of GetLinodeVolumes",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeVolumesResponses"
},
{
"name": "GetLinodeConfigsResponses",
"description": "GetLinodeConfigsResponses holds responses of GetLinodeConfigs",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeConfigsResponses"
},
{
"name": "AddLinodeConfigParameters",
"description": "AddLinodeConfigParameters holds parameters to AddLinodeConfig",
"fields": [
{
"name": "linodeconfig",
"type": "LinodeConfig",
"nativeType": "LinodeConfig",
"fieldName": "Linodeconfig",
"parameterName": "linodeconfig",
"serialize": true
}
],
"typeName": "AddLinodeConfigParameters"
},
{
"name": "AddLinodeConfigResponses",
"description": "AddLinodeConfigResponses holds responses of AddLinodeConfig",
"fields": [
{
"name": "200",
"type": "LinodeConfig",
"kind": 3,
"nativeType": "LinodeConfig",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "AddLinodeConfigResponses"
},
{
"name": "GetLinodeConfigResponses",
"description": "GetLinodeConfigResponses holds responses of GetLinodeConfig",
"fields": [
{
"name": "200",
"type": "LinodeConfig",
"kind": 3,
"nativeType": "LinodeConfig",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeConfigResponses"
},
{
"name": "UpdateLinodeConfigParameters",
"description": "UpdateLinodeConfigParameters holds parameters to UpdateLinodeConfig",
"fields": [
{
"name": "linodeconfig",
"type": "LinodeConfig",
"nativeType": "LinodeConfig",
"fieldName": "Linodeconfig",
"parameterName": "linodeconfig",
"serialize": true
}
],
"typeName": "UpdateLinodeConfigParameters"
},
{
"name": "UpdateLinodeConfigResponses",
"description": "UpdateLinodeConfigResponses holds responses of UpdateLinodeConfig",
"fields": [
{
"name": "200",
"type": "LinodeConfig",
"kind": 3,
"nativeType": "LinodeConfig",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateLinodeConfigResponses"
},
{
"name": "DELETE_linode_instances_linodeId_configs_configIdResponses",
"description": "DELETE_linode_instances_linodeId_configs_configIdResponses holds responses of DELETE_linode_instances_linodeId_configs_configId",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DELETE_linode_instances_linodeId_configs_configIdResponses"
},
{
"name": "GetLinodeDisksResponses",
"description": "GetLinodeDisksResponses holds responses of GetLinodeDisks",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeDisksResponses"
},
{
"name": "AddLinodeDiskParameters",
"description": "AddLinodeDiskParameters holds parameters to AddLinodeDisk",
"fields": [
{
"name": "diskrequest",
"type": "DiskRequest",
"nativeType": "DiskRequest",
"fieldName": "Diskrequest",
"parameterName": "diskrequest",
"serialize": true
}
],
"typeName": "AddLinodeDiskParameters"
},
{
"name": "AddLinodeDiskResponses",
"description": "AddLinodeDiskResponses holds responses of AddLinodeDisk",
"fields": [
{
"name": "200",
"type": "Disk",
"kind": 3,
"nativeType": "Disk",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "AddLinodeDiskResponses"
},
{
"name": "GetLinodeDiskResponses",
"description": "GetLinodeDiskResponses holds responses of GetLinodeDisk",
"fields": [
{
"name": "200",
"type": "Disk",
"kind": 3,
"nativeType": "Disk",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeDiskResponses"
},
{
"name": "UpdateDiskParameters",
"description": "UpdateDiskParameters holds parameters to UpdateDisk",
"fields": [
{
"name": "disk",
"type": "Disk",
"nativeType": "Disk",
"fieldName": "Disk",
"parameterName": "disk",
"serialize": true
}
],
"typeName": "UpdateDiskParameters"
},
{
"name": "UpdateDiskResponses",
"description": "UpdateDiskResponses holds responses of UpdateDisk",
"fields": [
{
"name": "200",
"type": "Disk",
"kind": 3,
"nativeType": "Disk",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateDiskResponses"
},
{
"name": "DeleteDiskResponses",
"description": "DeleteDiskResponses holds responses of DeleteDisk",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteDiskResponses"
},
{
"name": "ResetDiskPasswordParameters",
"description": "ResetDiskPasswordParameters holds parameters to ResetDiskPassword",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "ResetDiskPasswordParameters"
},
{
"name": "ResetDiskPasswordResponses",
"description": "ResetDiskPasswordResponses holds responses of ResetDiskPassword",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ResetDiskPasswordResponses"
},
{
"name": "ResizeDiskParameters",
"description": "ResizeDiskParameters holds parameters to ResizeDisk",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "ResizeDiskParameters"
},
{
"name": "ResizeDiskResponses",
"description": "ResizeDiskResponses holds responses of ResizeDisk",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ResizeDiskResponses"
},
{
"name": "GetLinodeStatsResponses",
"description": "GetLinodeStatsResponses holds responses of GetLinodeStats",
"fields": [
{
"name": "200",
"type": "LinodeStats",
"kind": 3,
"nativeType": "LinodeStats",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeStatsResponses"
},
{
"name": "GetLinodeStatsByYearMonthResponses",
"description": "GetLinodeStatsByYearMonthResponses holds responses of GetLinodeStatsByYearMonth",
"fields": [
{
"name": "200",
"type": "LinodeStats",
"kind": 3,
"nativeType": "LinodeStats",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeStatsByYearMonthResponses"
},
{
"name": "GetKernelsResponses",
"description": "GetKernelsResponses holds responses of GetKernels",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetKernelsResponses"
},
{
"name": "GetKernelResponses",
"description": "GetKernelResponses holds responses of GetKernel",
"fields": [
{
"name": "200",
"type": "Kernel",
"kind": 3,
"nativeType": "Kernel",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetKernelResponses"
},
{
"name": "GetStackScriptsResponses",
"description": "GetStackScriptsResponses holds responses of GetStackScripts",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetStackScriptsResponses"
},
{
"name": "AddStackScriptParameters",
"description": "AddStackScriptParameters holds parameters to AddStackScript",
"fields": [
{
"name": "stackscript",
"type": "StackScript",
"nativeType": "StackScript",
"fieldName": "Stackscript",
"parameterName": "stackscript",
"serialize": true
}
],
"typeName": "AddStackScriptParameters"
},
{
"name": "AddStackScriptResponses",
"description": "AddStackScriptResponses holds responses of AddStackScript",
"fields": [
{
"name": "200",
"type": "StackScript",
"kind": 3,
"nativeType": "StackScript",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "AddStackScriptResponses"
},
{
"name": "GetStackScriptResponses",
"description": "GetStackScriptResponses holds responses of GetStackScript",
"fields": [
{
"name": "200",
"type": "StackScript",
"kind": 3,
"nativeType": "StackScript",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetStackScriptResponses"
},
{
"name": "UpdateStackScriptResponses",
"description": "UpdateStackScriptResponses holds responses of UpdateStackScript",
"fields": [
{
"name": "200",
"type": "StackScript",
"kind": 3,
"nativeType": "StackScript",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateStackScriptResponses"
},
{
"name": "DeleteStackScriptResponses",
"description": "DeleteStackScriptResponses holds responses of DeleteStackScript",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteStackScriptResponses"
},
{
"name": "GetLinodeTypesResponses",
"description": "GetLinodeTypesResponses holds responses of GetLinodeTypes",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeTypesResponses"
},
{
"name": "GetLinodeTypeResponses",
"description": "GetLinodeTypeResponses holds responses of GetLinodeType",
"fields": [
{
"name": "200",
"type": "LinodeType",
"kind": 3,
"nativeType": "LinodeType",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLinodeTypeResponses"
},
{
"name": "GetManagedContactsResponses",
"description": "GetManagedContactsResponses holds responses of GetManagedContacts",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedContactsResponses"
},
{
"name": "CreateManagedContactParameters",
"description": "CreateManagedContactParameters holds parameters to CreateManagedContact",
"fields": [
{
"name": "managedcontact",
"type": "ManagedContact",
"nativeType": "ManagedContact",
"fieldName": "Managedcontact",
"parameterName": "managedcontact",
"serialize": true
}
],
"typeName": "CreateManagedContactParameters"
},
{
"name": "CreateManagedContactResponses",
"description": "CreateManagedContactResponses holds responses of CreateManagedContact",
"fields": [
{
"name": "200",
"type": "ManagedContact",
"kind": 3,
"nativeType": "ManagedContact",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateManagedContactResponses"
},
{
"name": "GetManagedContactResponses",
"description": "GetManagedContactResponses holds responses of GetManagedContact",
"fields": [
{
"name": "200",
"type": "ManagedContact",
"kind": 3,
"nativeType": "ManagedContact",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedContactResponses"
},
{
"name": "UpdateManagedContactParameters",
"description": "UpdateManagedContactParameters holds parameters to UpdateManagedContact",
"fields": [
{
"name": "managedcontact",
"type": "ManagedContact",
"nativeType": "ManagedContact",
"fieldName": "Managedcontact",
"parameterName": "managedcontact",
"serialize": true
}
],
"typeName": "UpdateManagedContactParameters"
},
{
"name": "UpdateManagedContactResponses",
"description": "UpdateManagedContactResponses holds responses of UpdateManagedContact",
"fields": [
{
"name": "200",
"type": "ManagedContact",
"kind": 3,
"nativeType": "ManagedContact",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateManagedContactResponses"
},
{
"name": "DeleteManagedContactResponses",
"description": "DeleteManagedContactResponses holds responses of DeleteManagedContact",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteManagedContactResponses"
},
{
"name": "GetManagedCredentialsResponses",
"description": "GetManagedCredentialsResponses holds responses of GetManagedCredentials",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedCredentialsResponses"
},
{
"name": "CreateManagedCredentialParameters",
"description": "CreateManagedCredentialParameters holds parameters to CreateManagedCredential",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateManagedCredentialParameters"
},
{
"name": "CreateManagedCredentialResponses",
"description": "CreateManagedCredentialResponses holds responses of CreateManagedCredential",
"fields": [
{
"name": "200",
"type": "ManagedCredential",
"kind": 3,
"nativeType": "ManagedCredential",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateManagedCredentialResponses"
},
{
"name": "GetManagedCredentialResponses",
"description": "GetManagedCredentialResponses holds responses of GetManagedCredential",
"fields": [
{
"name": "200",
"type": "ManagedCredential",
"kind": 3,
"nativeType": "ManagedCredential",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedCredentialResponses"
},
{
"name": "UpdateManagedCredentialParameters",
"description": "UpdateManagedCredentialParameters holds parameters to UpdateManagedCredential",
"fields": [
{
"name": "managedcredential",
"type": "ManagedCredential",
"nativeType": "ManagedCredential",
"fieldName": "Managedcredential",
"parameterName": "managedcredential",
"serialize": true
}
],
"typeName": "UpdateManagedCredentialParameters"
},
{
"name": "UpdateManagedCredentialResponses",
"description": "UpdateManagedCredentialResponses holds responses of UpdateManagedCredential",
"fields": [
{
"name": "200",
"type": "ManagedCredential",
"kind": 3,
"nativeType": "ManagedCredential",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateManagedCredentialResponses"
},
{
"name": "DeleteManagedCredentialResponses",
"description": "DeleteManagedCredentialResponses holds responses of DeleteManagedCredential",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteManagedCredentialResponses"
},
{
"name": "GetManagedIssuesResponses",
"description": "GetManagedIssuesResponses holds responses of GetManagedIssues",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedIssuesResponses"
},
{
"name": "GetManagedIssueResponses",
"description": "GetManagedIssueResponses holds responses of GetManagedIssue",
"fields": [
{
"name": "200",
"type": "ManagedIssue",
"kind": 3,
"nativeType": "ManagedIssue",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedIssueResponses"
},
{
"name": "GetManagedLinodeSettingsResponses",
"description": "GetManagedLinodeSettingsResponses holds responses of GetManagedLinodeSettings",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedLinodeSettingsResponses"
},
{
"name": "GetManagedLinodeSettingResponses",
"description": "GetManagedLinodeSettingResponses holds responses of GetManagedLinodeSetting",
"fields": [
{
"name": "200",
"type": "ManagedLinodeSettings",
"kind": 3,
"nativeType": "ManagedLinodeSettings",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedLinodeSettingResponses"
},
{
"name": "UpdateManagedLinodeSettingParameters",
"description": "UpdateManagedLinodeSettingParameters holds parameters to UpdateManagedLinodeSetting",
"fields": [
{
"name": "managedlinodesettings",
"type": "ManagedLinodeSettings",
"nativeType": "ManagedLinodeSettings",
"fieldName": "Managedlinodesettings",
"parameterName": "managedlinodesettings",
"serialize": true
}
],
"typeName": "UpdateManagedLinodeSettingParameters"
},
{
"name": "UpdateManagedLinodeSettingResponses",
"description": "UpdateManagedLinodeSettingResponses holds responses of UpdateManagedLinodeSetting",
"fields": [
{
"name": "200",
"type": "ManagedLinodeSettings",
"kind": 3,
"nativeType": "ManagedLinodeSettings",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateManagedLinodeSettingResponses"
},
{
"name": "GetManagedServicesResponses",
"description": "GetManagedServicesResponses holds responses of GetManagedServices",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedServicesResponses"
},
{
"name": "CreateManagedServiceParameters",
"description": "CreateManagedServiceParameters holds parameters to CreateManagedService",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateManagedServiceParameters"
},
{
"name": "CreateManagedServiceResponses",
"description": "CreateManagedServiceResponses holds responses of CreateManagedService",
"fields": [
{
"name": "200",
"type": "ManagedService",
"kind": 3,
"nativeType": "ManagedService",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateManagedServiceResponses"
},
{
"name": "GetManagedServiceResponses",
"description": "GetManagedServiceResponses holds responses of GetManagedService",
"fields": [
{
"name": "200",
"type": "ManagedService",
"kind": 3,
"nativeType": "ManagedService",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetManagedServiceResponses"
},
{
"name": "UpdateManagedServiceParameters",
"description": "UpdateManagedServiceParameters holds parameters to UpdateManagedService",
"fields": [
{
"name": "managedservice",
"type": "ManagedService",
"nativeType": "ManagedService",
"fieldName": "Managedservice",
"parameterName": "managedservice",
"serialize": true
}
],
"typeName": "UpdateManagedServiceParameters"
},
{
"name": "UpdateManagedServiceResponses",
"description": "UpdateManagedServiceResponses holds responses of UpdateManagedService",
"fields": [
{
"name": "200",
"type": "ManagedService",
"kind": 3,
"nativeType": "ManagedService",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateManagedServiceResponses"
},
{
"name": "DeleteManagedServiceResponses",
"description": "DeleteManagedServiceResponses holds responses of DeleteManagedService",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteManagedServiceResponses"
},
{
"name": "DisableManagedServiceResponses",
"description": "DisableManagedServiceResponses holds responses of DisableManagedService",
"fields": [
{
"name": "200",
"type": "ManagedService",
"kind": 3,
"nativeType": "ManagedService",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DisableManagedServiceResponses"
},
{
"name": "EnableManagedServiceResponses",
"description": "EnableManagedServiceResponses holds responses of EnableManagedService",
"fields": [
{
"name": "200",
"type": "ManagedService",
"kind": 3,
"nativeType": "ManagedService",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "EnableManagedServiceResponses"
},
{
"name": "GetIPsResponses",
"description": "GetIPsResponses holds responses of GetIPs",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetIPsResponses"
},
{
"name": "AllocateIPParameters",
"description": "AllocateIPParameters holds parameters to AllocateIP",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "AllocateIPParameters"
},
{
"name": "AllocateIPResponses",
"description": "AllocateIPResponses holds responses of AllocateIP",
"fields": [
{
"name": "200",
"type": "IPAddress",
"kind": 3,
"nativeType": "IPAddress",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "AllocateIPResponses"
},
{
"name": "GetIPResponses",
"description": "GetIPResponses holds responses of GetIP",
"fields": [
{
"name": "200",
"type": "IPAddress",
"kind": 3,
"nativeType": "IPAddress",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetIPResponses"
},
{
"name": "UpdateIPParameters",
"description": "UpdateIPParameters holds parameters to UpdateIP",
"fields": [
{
"name": "ipaddress",
"type": "IPAddress",
"nativeType": "IPAddress",
"fieldName": "Ipaddress",
"parameterName": "ipaddress",
"serialize": true
}
],
"typeName": "UpdateIPParameters"
},
{
"name": "UpdateIPResponses",
"description": "UpdateIPResponses holds responses of UpdateIP",
"fields": [
{
"name": "200",
"type": "IPAddress",
"kind": 3,
"nativeType": "IPAddress",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateIPResponses"
},
{
"name": "GetLongviewClientsResponses",
"description": "GetLongviewClientsResponses holds responses of GetLongviewClients",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLongviewClientsResponses"
},
{
"name": "CreateLongviewClientParameters",
"description": "CreateLongviewClientParameters holds parameters to CreateLongviewClient",
"fields": [
{
"name": "longviewclient",
"type": "LongviewClient",
"nativeType": "LongviewClient",
"fieldName": "Longviewclient",
"parameterName": "longviewclient",
"serialize": true
}
],
"typeName": "CreateLongviewClientParameters"
},
{
"name": "CreateLongviewClientResponses",
"description": "CreateLongviewClientResponses holds responses of CreateLongviewClient",
"fields": [
{
"name": "200",
"type": "LongviewClient",
"kind": 3,
"nativeType": "LongviewClient",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateLongviewClientResponses"
},
{
"name": "GetLongviewClientResponses",
"description": "GetLongviewClientResponses holds responses of GetLongviewClient",
"fields": [
{
"name": "200",
"type": "LongviewClient",
"kind": 3,
"nativeType": "LongviewClient",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLongviewClientResponses"
},
{
"name": "UpdateLongviewClientParameters",
"description": "UpdateLongviewClientParameters holds parameters to UpdateLongviewClient",
"fields": [
{
"name": "longviewclient",
"type": "LongviewClient",
"nativeType": "LongviewClient",
"fieldName": "Longviewclient",
"parameterName": "longviewclient",
"serialize": true
}
],
"typeName": "UpdateLongviewClientParameters"
},
{
"name": "UpdateLongviewClientResponses",
"description": "UpdateLongviewClientResponses holds responses of UpdateLongviewClient",
"fields": [
{
"name": "200",
"type": "LongviewClient",
"kind": 3,
"nativeType": "LongviewClient",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateLongviewClientResponses"
},
{
"name": "DeleteLongviewClientResponses",
"description": "DeleteLongviewClientResponses holds responses of DeleteLongviewClient",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteLongviewClientResponses"
},
{
"name": "GetLongviewSubscriptionsResponses",
"description": "GetLongviewSubscriptionsResponses holds responses of GetLongviewSubscriptions",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLongviewSubscriptionsResponses"
},
{
"name": "GetLongviewSubscriptionResponses",
"description": "GetLongviewSubscriptionResponses holds responses of GetLongviewSubscription",
"fields": [
{
"name": "200",
"type": "LongviewSubscription",
"kind": 3,
"nativeType": "LongviewSubscription",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetLongviewSubscriptionResponses"
},
{
"name": "AssignIPsParameters",
"description": "AssignIPsParameters holds parameters to AssignIPs",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "AssignIPsParameters"
},
{
"name": "AssignIPsResponses",
"description": "AssignIPsResponses holds responses of AssignIPs",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "AssignIPsResponses"
},
{
"name": "ShareIPsParameters",
"description": "ShareIPsParameters holds parameters to ShareIPs",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "ShareIPsParameters"
},
{
"name": "ShareIPsResponses",
"description": "ShareIPsResponses holds responses of ShareIPs",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ShareIPsResponses"
},
{
"name": "GetIPv6PoolsResponses",
"description": "GetIPv6PoolsResponses holds responses of GetIPv6Pools",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetIPv6PoolsResponses"
},
{
"name": "GetIPv6RangesResponses",
"description": "GetIPv6RangesResponses holds responses of GetIPv6Ranges",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetIPv6RangesResponses"
},
{
"name": "GetNodeBalancersResponses",
"description": "GetNodeBalancersResponses holds responses of GetNodeBalancers",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetNodeBalancersResponses"
},
{
"name": "CreateNodeBalancerParameters",
"description": "CreateNodeBalancerParameters holds parameters to CreateNodeBalancer",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateNodeBalancerParameters"
},
{
"name": "CreateNodeBalancerResponses",
"description": "CreateNodeBalancerResponses holds responses of CreateNodeBalancer",
"fields": [
{
"name": "200",
"type": "NodeBalancer",
"kind": 3,
"nativeType": "NodeBalancer",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateNodeBalancerResponses"
},
{
"name": "GetNodeBalancerResponses",
"description": "GetNodeBalancerResponses holds responses of GetNodeBalancer",
"fields": [
{
"name": "200",
"type": "NodeBalancer",
"kind": 3,
"nativeType": "NodeBalancer",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetNodeBalancerResponses"
},
{
"name": "UpdateNodeBalancerParameters",
"description": "UpdateNodeBalancerParameters holds parameters to UpdateNodeBalancer",
"fields": [
{
"name": "nodebalancer",
"type": "NodeBalancer",
"nativeType": "NodeBalancer",
"fieldName": "Nodebalancer",
"parameterName": "nodebalancer",
"serialize": true
}
],
"typeName": "UpdateNodeBalancerParameters"
},
{
"name": "UpdateNodeBalancerResponses",
"description": "UpdateNodeBalancerResponses holds responses of UpdateNodeBalancer",
"fields": [
{
"name": "200",
"type": "NodeBalancer",
"kind": 3,
"nativeType": "NodeBalancer",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateNodeBalancerResponses"
},
{
"name": "DeleteNodeBalancerResponses",
"description": "DeleteNodeBalancerResponses holds responses of DeleteNodeBalancer",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteNodeBalancerResponses"
},
{
"name": "GetNodeBalancerConfigsResponses",
"description": "GetNodeBalancerConfigsResponses holds responses of GetNodeBalancerConfigs",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetNodeBalancerConfigsResponses"
},
{
"name": "CreateaNodeBalancerConfigParameters",
"description": "CreateaNodeBalancerConfigParameters holds parameters to CreateaNodeBalancerConfig",
"fields": [
{
"name": "nodebalancerconfig",
"type": "NodeBalancerConfig",
"nativeType": "NodeBalancerConfig",
"fieldName": "Nodebalancerconfig",
"parameterName": "nodebalancerconfig",
"serialize": true
}
],
"typeName": "CreateaNodeBalancerConfigParameters"
},
{
"name": "CreateaNodeBalancerConfigResponses",
"description": "CreateaNodeBalancerConfigResponses holds responses of CreateaNodeBalancerConfig",
"fields": [
{
"name": "200",
"type": "NodeBalancerConfig",
"kind": 3,
"nativeType": "NodeBalancerConfig",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateaNodeBalancerConfigResponses"
},
{
"name": "GetNodeBalancerConfigResponses",
"description": "GetNodeBalancerConfigResponses holds responses of GetNodeBalancerConfig",
"fields": [
{
"name": "200",
"type": "NodeBalancerConfig",
"kind": 3,
"nativeType": "NodeBalancerConfig",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetNodeBalancerConfigResponses"
},
{
"name": "UpdateNodeBalancerConfigParameters",
"description": "UpdateNodeBalancerConfigParameters holds parameters to UpdateNodeBalancerConfig",
"fields": [
{
"name": "nodebalancerconfig",
"type": "NodeBalancerConfig",
"nativeType": "NodeBalancerConfig",
"fieldName": "Nodebalancerconfig",
"parameterName": "nodebalancerconfig",
"serialize": true
}
],
"typeName": "UpdateNodeBalancerConfigParameters"
},
{
"name": "UpdateNodeBalancerConfigResponses",
"description": "UpdateNodeBalancerConfigResponses holds responses of UpdateNodeBalancerConfig",
"fields": [
{
"name": "200",
"type": "NodeBalancerConfig",
"kind": 3,
"nativeType": "NodeBalancerConfig",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateNodeBalancerConfigResponses"
},
{
"name": "DeleteNodeBalancerConfigResponses",
"description": "DeleteNodeBalancerConfigResponses holds responses of DeleteNodeBalancerConfig",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteNodeBalancerConfigResponses"
},
{
"name": "GetNodeBalancerConfigNodesResponses",
"description": "GetNodeBalancerConfigNodesResponses holds responses of GetNodeBalancerConfigNodes",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetNodeBalancerConfigNodesResponses"
},
{
"name": "CreateNodeBalancerNodeParameters",
"description": "CreateNodeBalancerNodeParameters holds parameters to CreateNodeBalancerNode",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateNodeBalancerNodeParameters"
},
{
"name": "CreateNodeBalancerNodeResponses",
"description": "CreateNodeBalancerNodeResponses holds responses of CreateNodeBalancerNode",
"fields": [
{
"name": "200",
"type": "NodeBalancerNode",
"kind": 3,
"nativeType": "NodeBalancerNode",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateNodeBalancerNodeResponses"
},
{
"name": "GetNodeBalancerNodeResponses",
"description": "GetNodeBalancerNodeResponses holds responses of GetNodeBalancerNode",
"fields": [
{
"name": "200",
"type": "NodeBalancerNode",
"kind": 3,
"nativeType": "NodeBalancerNode",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetNodeBalancerNodeResponses"
},
{
"name": "UpdateNodeBalancerNodeParameters",
"description": "UpdateNodeBalancerNodeParameters holds parameters to UpdateNodeBalancerNode",
"fields": [
{
"name": "nodebalancernode",
"type": "NodeBalancerNode",
"nativeType": "NodeBalancerNode",
"fieldName": "Nodebalancernode",
"parameterName": "nodebalancernode",
"serialize": true
}
],
"typeName": "UpdateNodeBalancerNodeParameters"
},
{
"name": "UpdateNodeBalancerNodeResponses",
"description": "UpdateNodeBalancerNodeResponses holds responses of UpdateNodeBalancerNode",
"fields": [
{
"name": "200",
"type": "NodeBalancerNode",
"kind": 3,
"nativeType": "NodeBalancerNode",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateNodeBalancerNodeResponses"
},
{
"name": "DeleteNodeBalancerConfigNodeResponses",
"description": "DeleteNodeBalancerConfigNodeResponses holds responses of DeleteNodeBalancerConfigNode",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteNodeBalancerConfigNodeResponses"
},
{
"name": "GetRegionsResponses",
"description": "GetRegionsResponses holds responses of GetRegions",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetRegionsResponses"
},
{
"name": "GetRegionResponses",
"description": "GetRegionResponses holds responses of GetRegion",
"fields": [
{
"name": "200",
"type": "Region",
"kind": 3,
"nativeType": "Region",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetRegionResponses"
},
{
"name": "GetVolumesResponses",
"description": "GetVolumesResponses holds responses of GetVolumes",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetVolumesResponses"
},
{
"name": "CreateVolumeParameters",
"description": "CreateVolumeParameters holds parameters to CreateVolume",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateVolumeParameters"
},
{
"name": "CreateVolumeResponses",
"description": "CreateVolumeResponses holds responses of CreateVolume",
"fields": [
{
"name": "200",
"type": "Volume",
"kind": 3,
"nativeType": "Volume",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateVolumeResponses"
},
{
"name": "GetVolumeResponses",
"description": "GetVolumeResponses holds responses of GetVolume",
"fields": [
{
"name": "200",
"type": "Volume",
"kind": 3,
"nativeType": "Volume",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetVolumeResponses"
},
{
"name": "UpdateVolumeParameters",
"description": "UpdateVolumeParameters holds parameters to UpdateVolume",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "UpdateVolumeParameters"
},
{
"name": "UpdateVolumeResponses",
"description": "UpdateVolumeResponses holds responses of UpdateVolume",
"fields": [
{
"name": "200",
"type": "Volume",
"kind": 3,
"nativeType": "Volume",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateVolumeResponses"
},
{
"name": "DeleteVolumeResponses",
"description": "DeleteVolumeResponses holds responses of DeleteVolume",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteVolumeResponses"
},
{
"name": "AttachVolumeParameters",
"description": "AttachVolumeParameters holds parameters to AttachVolume",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "AttachVolumeParameters"
},
{
"name": "AttachVolumeResponses",
"description": "AttachVolumeResponses holds responses of AttachVolume",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "AttachVolumeResponses"
},
{
"name": "CloneVolumeParameters",
"description": "CloneVolumeParameters holds parameters to CloneVolume",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CloneVolumeParameters"
},
{
"name": "CloneVolumeResponses",
"description": "CloneVolumeResponses holds responses of CloneVolume",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CloneVolumeResponses"
},
{
"name": "DetachVolumeResponses",
"description": "DetachVolumeResponses holds responses of DetachVolume",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DetachVolumeResponses"
},
{
"name": "ResizeVolumeParameters",
"description": "ResizeVolumeParameters holds parameters to ResizeVolume",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "ResizeVolumeParameters"
},
{
"name": "ResizeVolumeResponses",
"description": "ResizeVolumeResponses holds responses of ResizeVolume",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "ResizeVolumeResponses"
},
{
"name": "GetDomainRecordsResponses",
"description": "GetDomainRecordsResponses holds responses of GetDomainRecords",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetDomainRecordsResponses"
},
{
"name": "POST_domains_domainId_recordsParameters",
"description": "POST_domains_domainId_recordsParameters holds parameters to POST_domains_domainId_records",
"fields": [
{
"name": "domainrecord",
"type": "DomainRecord",
"nativeType": "DomainRecord",
"fieldName": "Domainrecord",
"parameterName": "domainrecord",
"serialize": true
}
],
"typeName": "POST_domains_domainId_recordsParameters"
},
{
"name": "POST_domains_domainId_recordsResponses",
"description": "POST_domains_domainId_recordsResponses holds responses of POST_domains_domainId_records",
"fields": [
{
"name": "200",
"type": "DomainRecord",
"kind": 3,
"nativeType": "DomainRecord",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "POST_domains_domainId_recordsResponses"
},
{
"name": "GET_domains_domainId_records_recordIdResponses",
"description": "GET_domains_domainId_records_recordIdResponses holds responses of GET_domains_domainId_records_recordId",
"fields": [
{
"name": "200",
"type": "DomainRecord",
"kind": 3,
"nativeType": "DomainRecord",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GET_domains_domainId_records_recordIdResponses"
},
{
"name": "PUT_domains_domainId_records_recordIdParameters",
"description": "PUT_domains_domainId_records_recordIdParameters holds parameters to PUT_domains_domainId_records_recordId",
"fields": [
{
"name": "domainrecord",
"type": "DomainRecord",
"nativeType": "DomainRecord",
"fieldName": "Domainrecord",
"parameterName": "domainrecord",
"serialize": true
}
],
"typeName": "PUT_domains_domainId_records_recordIdParameters"
},
{
"name": "PUT_domains_domainId_records_recordIdResponses",
"description": "PUT_domains_domainId_records_recordIdResponses holds responses of PUT_domains_domainId_records_recordId",
"fields": [
{
"name": "200",
"type": "DomainRecord",
"kind": 3,
"nativeType": "DomainRecord",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "PUT_domains_domainId_records_recordIdResponses"
},
{
"name": "DELETE_domains_domainId_records_recordIdResponses",
"description": "DELETE_domains_domainId_records_recordIdResponses holds responses of DELETE_domains_domainId_records_recordId",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DELETE_domains_domainId_records_recordIdResponses"
},
{
"name": "GetProfileResponses",
"description": "GetProfileResponses holds responses of GetProfile",
"fields": [
{
"name": "200",
"type": "Profile",
"kind": 3,
"nativeType": "Profile",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetProfileResponses"
},
{
"name": "UpdateProfileParameters",
"description": "UpdateProfileParameters holds parameters to UpdateProfile",
"fields": [
{
"name": "profile",
"type": "Profile",
"nativeType": "Profile",
"fieldName": "Profile",
"parameterName": "profile",
"serialize": true
}
],
"typeName": "UpdateProfileParameters"
},
{
"name": "UpdateProfileResponses",
"description": "UpdateProfileResponses holds responses of UpdateProfile",
"fields": [
{
"name": "200",
"type": "Profile",
"kind": 3,
"nativeType": "Profile",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdateProfileResponses"
},
{
"name": "GetProfileAppsResponses",
"description": "GetProfileAppsResponses holds responses of GetProfileApps",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetProfileAppsResponses"
},
{
"name": "GetProfileAppResponses",
"description": "GetProfileAppResponses holds responses of GetProfileApp",
"fields": [
{
"name": "200",
"type": "AuthorizedApp",
"kind": 3,
"nativeType": "AuthorizedApp",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetProfileAppResponses"
},
{
"name": "DeleteProfileAppResponses",
"description": "DeleteProfileAppResponses holds responses of DeleteProfileApp",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeleteProfileAppResponses"
},
{
"name": "GetProfileGrantsResponses",
"description": "GetProfileGrantsResponses holds responses of GetProfileGrants",
"fields": [
{
"name": "200",
"type": "GrantsResponse",
"kind": 3,
"nativeType": "GrantsResponse",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetProfileGrantsResponses"
},
{
"name": "TfaEnableResponses",
"description": "TfaEnableResponses holds responses of TfaEnable",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "TfaEnableResponses"
},
{
"name": "TfaConfirmParameters",
"description": "TfaConfirmParameters holds parameters to TfaConfirm",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "TfaConfirmParameters"
},
{
"name": "TfaConfirmResponses",
"description": "TfaConfirmResponses holds responses of TfaConfirm",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "TfaConfirmResponses"
},
{
"name": "TfaDisableResponses",
"description": "TfaDisableResponses holds responses of TfaDisable",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "TfaDisableResponses"
},
{
"name": "GetPersonalAccessTokensResponses",
"description": "GetPersonalAccessTokensResponses holds responses of GetPersonalAccessTokens",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetPersonalAccessTokensResponses"
},
{
"name": "CreatePersonalAccessTokenParameters",
"description": "CreatePersonalAccessTokenParameters holds parameters to CreatePersonalAccessToken",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreatePersonalAccessTokenParameters"
},
{
"name": "CreatePersonalAccessTokenResponses",
"description": "CreatePersonalAccessTokenResponses holds responses of CreatePersonalAccessToken",
"fields": [
{
"name": "200",
"type": "PersonalAccessToken",
"kind": 3,
"nativeType": "PersonalAccessToken",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreatePersonalAccessTokenResponses"
},
{
"name": "GetPersonalAccessTokenResponses",
"description": "GetPersonalAccessTokenResponses holds responses of GetPersonalAccessToken",
"fields": [
{
"name": "200",
"type": "PersonalAccessToken",
"kind": 3,
"nativeType": "PersonalAccessToken",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetPersonalAccessTokenResponses"
},
{
"name": "UpdatePersonalAccessTokenParameters",
"description": "UpdatePersonalAccessTokenParameters holds parameters to UpdatePersonalAccessToken",
"fields": [
{
"name": "personalaccesstoken",
"type": "PersonalAccessToken",
"nativeType": "PersonalAccessToken",
"fieldName": "Personalaccesstoken",
"parameterName": "personalaccesstoken",
"serialize": true
}
],
"typeName": "UpdatePersonalAccessTokenParameters"
},
{
"name": "UpdatePersonalAccessTokenResponses",
"description": "UpdatePersonalAccessTokenResponses holds responses of UpdatePersonalAccessToken",
"fields": [
{
"name": "200",
"type": "PersonalAccessToken",
"kind": 3,
"nativeType": "PersonalAccessToken",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "UpdatePersonalAccessTokenResponses"
},
{
"name": "DeletePersonalAccessTokenResponses",
"description": "DeletePersonalAccessTokenResponses holds responses of DeletePersonalAccessToken",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "DeletePersonalAccessTokenResponses"
},
{
"name": "GetTicketsResponses",
"description": "GetTicketsResponses holds responses of GetTickets",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetTicketsResponses"
},
{
"name": "CreateTicketParameters",
"description": "CreateTicketParameters holds parameters to CreateTicket",
"fields": [
{
"name": "supportticketrequest",
"type": "SupportTicketRequest",
"nativeType": "SupportTicketRequest",
"fieldName": "Supportticketrequest",
"parameterName": "supportticketrequest",
"serialize": true
}
],
"typeName": "CreateTicketParameters"
},
{
"name": "CreateTicketResponses",
"description": "CreateTicketResponses holds responses of CreateTicket",
"fields": [
{
"name": "200",
"type": "SupportTicket",
"kind": 3,
"nativeType": "SupportTicket",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateTicketResponses"
},
{
"name": "GetTicketResponses",
"description": "GetTicketResponses holds responses of GetTicket",
"fields": [
{
"name": "200",
"type": "SupportTicket",
"kind": 3,
"nativeType": "SupportTicket",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetTicketResponses"
},
{
"name": "CreateTicketAttachmentParameters",
"description": "CreateTicketAttachmentParameters holds parameters to CreateTicketAttachment",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateTicketAttachmentParameters"
},
{
"name": "CreateTicketAttachmentResponses",
"description": "CreateTicketAttachmentResponses holds responses of CreateTicketAttachment",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateTicketAttachmentResponses"
},
{
"name": "GetTicketRepliesResponses",
"description": "GetTicketRepliesResponses holds responses of GetTicketReplies",
"fields": [
{
"name": "200",
"type": "object",
"kind": 3,
"nativeType": "interface{}",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "GetTicketRepliesResponses"
},
{
"name": "CreateTicketReplyParameters",
"description": "CreateTicketReplyParameters holds parameters to CreateTicketReply",
"fields": [
{
"name": "object",
"type": "object",
"kind": 1,
"nativeType": "interface{}",
"fieldName": "Object",
"parameterName": "object",
"serialize": true
}
],
"typeName": "CreateTicketReplyParameters"
},
{
"name": "CreateTicketReplyResponses",
"description": "CreateTicketReplyResponses holds responses of CreateTicketReply",
"fields": [
{
"name": "200",
"type": "SupportTicketReply",
"kind": 3,
"nativeType": "SupportTicketReply",
"fieldName": "OK",
"parameterName": "200"
}
],
"typeName": "CreateTicketReplyResponses"
}
],
"methods": [
{
"operation": "getAccount",
"path": "/account",
"method": "GET",
"description": "This endpoint returns the contact and billing information related to your Account.\n",
"name": "GetAccount",
"handlerName": "HandleGetAccount",
"processorName": "GetAccount",
"clientName": "GetAccount",
"responsesTypeName": "GetAccountResponses"
},
{
"operation": "updateAccount",
"path": "/account",
"method": "PUT",
"description": "This endpoint allows you to update contact and billing information related to your Account.\n",
"name": "UpdateAccount",
"handlerName": "HandleUpdateAccount",
"processorName": "UpdateAccount",
"clientName": "UpdateAccount",
"parametersTypeName": "UpdateAccountParameters",
"responsesTypeName": "UpdateAccountResponses"
},
{
"operation": "createCreditCard",
"path": "/account/credit-card",
"method": "POST",
"description": "This endpoint allows you to add/edit credit card information to your Account.\nOnly one credit card can be associated with your Account, so using this endpoint will overwrite your card information with the new credit card.\n",
"name": "CreateCreditCard",
"handlerName": "HandleCreateCreditCard",
"processorName": "CreateCreditCard",
"clientName": "CreateCreditCard",
"parametersTypeName": "CreateCreditCardParameters",
"responsesTypeName": "CreateCreditCardResponses"
},
{
"operation": "getEvents",
"path": "/account/events",
"method": "GET",
"description": "This endpoint returns a collection of Event objects representing actions taken on your Account. The events returned depends on your grants.\n",
"name": "GetEvents",
"handlerName": "HandleGetEvents",
"processorName": "GetEvents",
"clientName": "GetEvents",
"responsesTypeName": "GetEventsResponses"
},
{
"operation": "getEvent",
"path": "/account/events/{eventId}",
"method": "GET",
"description": "Returns a single Event object.",
"name": "GetEvent",
"handlerName": "HandleGetEvent",
"processorName": "GetEvent",
"clientName": "GetEvent",
"responsesTypeName": "GetEventResponses"
},
{
"operation": "eventRead",
"path": "/account/events/{eventId}/read",
"method": "POST",
"description": "Marks Event as read.",
"name": "EventRead",
"handlerName": "HandleEventRead",
"processorName": "EventRead",
"clientName": "EventRead",
"responsesTypeName": "EventReadResponses"
},
{
"operation": "eventSeen",
"path": "/account/events/{eventId}/seen",
"method": "POST",
"description": "Marks all Events up to and including this Event by ID as seen.\n",
"name": "EventSeen",
"handlerName": "HandleEventSeen",
"processorName": "EventSeen",
"clientName": "EventSeen",
"responsesTypeName": "EventSeenResponses"
},
{
"operation": "getInvoices",
"path": "/account/invoices",
"method": "GET",
"description": "This endpoint returns a paginated list of invoices against your Account.\n",
"name": "GetInvoices",
"handlerName": "HandleGetInvoices",
"processorName": "GetInvoices",
"clientName": "GetInvoices",
"responsesTypeName": "GetInvoicesResponses"
},
{
"operation": "getInvoice",
"path": "/account/invoices/{invoiceId}",
"method": "GET",
"description": "Returns a single Invoice object.",
"name": "GetInvoice",
"handlerName": "HandleGetInvoice",
"processorName": "GetInvoice",
"clientName": "GetInvoice",
"responsesTypeName": "GetInvoiceResponses"
},
{
"operation": "getInvoiceItems",
"path": "/account/invoices/{invoiceId}/items",
"method": "GET",
"description": "Returns a paginated list of Invoice items.",
"name": "GetInvoiceItems",
"handlerName": "HandleGetInvoiceItems",
"processorName": "GetInvoiceItems",
"clientName": "GetInvoiceItems",
"responsesTypeName": "GetInvoiceItemsResponses"
},
{
"operation": "getNotifications",
"path": "/account/notifications",
"method": "GET",
"description": "This endpoint returns a collection of Notification objects representing important, often time-sensitive items related to your account.\nYou cannot interact directly with Notifications, and it will disappear when the circumstances causing the Notification have been resolved. For example, if you have an important ticket open, you must respond to the ticket to dismiss the Notification.\n",
"name": "GetNotifications",
"handlerName": "HandleGetNotifications",
"processorName": "GetNotifications",
"clientName": "GetNotifications",
"responsesTypeName": "GetNotificationsResponses"
},
{
"operation": "getClients",
"path": "/account/oauth-clients",
"method": "GET",
"description": "Returns a paginated list of OAuth Clients registered to your account. OAuth Clients allow users to log into applications you write or host using their Linode account, and may allow them to grant some level of access to their Linodes or other entities to your application.\n",
"name": "GetClients",
"handlerName": "HandleGetClients",
"processorName": "GetClients",
"clientName": "GetClients",
"responsesTypeName": "GetClientsResponses"
},
{
"operation": "createClient",
"path": "/account/oauth-clients",
"method": "POST",
"description": "Create a new OAuth Client, which can be used to allow users to login to your own applications using their Linode account, and optionally grant your application some amount of access to their Linodes or other entities.\n",
"name": "CreateClient",
"handlerName": "HandleCreateClient",
"processorName": "CreateClient",
"clientName": "CreateClient",
"parametersTypeName": "CreateClientParameters",
"responsesTypeName": "CreateClientResponses"
},
{
"operation": "getClient",
"path": "/account/oauth-clients/{clientId}",
"method": "GET",
"description": "Returns information about a single OAuth client.\n",
"name": "GetClient",
"handlerName": "HandleGetClient",
"processorName": "GetClient",
"clientName": "GetClient",
"responsesTypeName": "GetClientResponses"
},
{
"operation": "updateClient",
"path": "/account/oauth-clients/{clientId}",
"method": "PUT",
"description": "Update information about an OAuth Client on your account. This can be especially useful to update the redirect_uri of your client in the event that the callback url changed in your application.\n",
"name": "UpdateClient",
"handlerName": "HandleUpdateClient",
"processorName": "UpdateClient",
"clientName": "UpdateClient",
"parametersTypeName": "UpdateClientParameters",
"responsesTypeName": "UpdateClientResponses"
},
{
"operation": "deleteClient",
"path": "/account/oauth-clients/{clientId}",
"method": "DELETE",
"description": "Deletes an OAuth Client registered with Linode. The Client ID and Client Secret will no longer be accepted by https://login.linode.com, and all tokens issued to this client will be invalidated (meaning that if your application was using a token, it will no longer work).\n",
"name": "DeleteClient",
"handlerName": "HandleDeleteClient",
"processorName": "DeleteClient",
"clientName": "DeleteClient",
"responsesTypeName": "DeleteClientResponses"
},
{
"operation": "getClientThumbnail",
"path": "/account/oauth-clients/{clientId}/thumbnail",
"method": "GET",
"description": "Returns the thumbnail for this OAuth Client. This is a publicly-viewable endpoint, and can be accessed without authentication.\n",
"name": "GetClientThumbnail",
"handlerName": "HandleGetClientThumbnail",
"processorName": "GetClientThumbnail",
"clientName": "GetClientThumbnail",
"responsesTypeName": "GetClientThumbnailResponses"
},
{
"operation": "setClientThumbnail",
"path": "/account/oauth-clients/{clientId}/thumbnail",
"method": "PUT",
"description": "Upload a thumbnail for a client you own. You must upload an image file that will be returned when the thumbnail is retrieved. This image will be publicly-viewable.\n",
"name": "SetClientThumbnail",
"handlerName": "HandleSetClientThumbnail",
"processorName": "SetClientThumbnail",
"clientName": "SetClientThumbnail",
"parametersTypeName": "SetClientThumbnailParameters",
"responsesTypeName": "SetClientThumbnailResponses"
},
{
"operation": "resetClientSecret",
"path": "/account/oauth-clients/{clientId}/reset-secret",
"method": "POST",
"description": "Resets the OAuth Client Secret for a client you own, and returns the OAuth Client with the plaintext secret. This secret is not supposed to be publicly known or disclosed anywhere. This can be used to generate a new secret in case the one you have has been leaked, or to get a new secret if you lost the original. The old secret is expired immediately, and logins to your client with the old secret will fail.\n",
"name": "ResetClientSecret",
"handlerName": "HandleResetClientSecret",
"processorName": "ResetClientSecret",
"clientName": "ResetClientSecret",
"responsesTypeName": "ResetClientSecretResponses"
},
{
"operation": "getPayments",
"path": "/account/payments",
"method": "GET",
"description": "This endpoint returns a paginated list of Payments made on this Account.\n",
"name": "GetPayments",
"handlerName": "HandleGetPayments",
"processorName": "GetPayments",
"clientName": "GetPayments",
"responsesTypeName": "GetPaymentsResponses"
},
{
"operation": "createPayment",
"path": "/account/payments",
"method": "POST",
"description": "This endpoint allows you to make a payment to your Account via credit card. This will charge your credit card the requested amount.\n",
"name": "CreatePayment",
"handlerName": "HandleCreatePayment",
"processorName": "CreatePayment",
"clientName": "CreatePayment",
"parametersTypeName": "CreatePaymentParameters",
"responsesTypeName": "CreatePaymentResponses"
},
{
"operation": "getPayment",
"path": "/account/payments/{paymentId}",
"method": "GET",
"description": "Returns information about a specific Payment.\n",
"name": "GetPayment",
"handlerName": "HandleGetPayment",
"processorName": "GetPayment",
"clientName": "GetPayment",
"responsesTypeName": "GetPaymentResponses"
},
{
"operation": "createPayPalPayment",
"path": "/account/payments/paypal",
"method": "POST",
"description": "This begins the process of submitting a payment via PayPal. After calling\n this endpoint, you must take the resulting `payment_id` along with\n the `payer_id` from your PayPal account, and POST to\n`/account/payments/paypal-execute` to complete the payment.\n",
"name": "CreatePayPalPayment",
"handlerName": "HandleCreatePayPalPayment",
"processorName": "CreatePayPalPayment",
"clientName": "CreatePayPalPayment",
"parametersTypeName": "CreatePayPalPaymentParameters",
"responsesTypeName": "CreatePayPalPaymentResponses"
},
{
"operation": "executePayPalPayment",
"path": "/account/payment/paypal/execute",
"method": "POST",
"description": "Given a PaymentID and PayerID - as generated by PayPal during the transaction authorization process - this endpoint executes the payment to capture the funds and credit your Linode account.\n",
"name": "ExecutePayPalPayment",
"handlerName": "HandleExecutePayPalPayment",
"processorName": "ExecutePayPalPayment",
"clientName": "ExecutePayPalPayment",
"parametersTypeName": "ExecutePayPalPaymentParameters",
"responsesTypeName": "ExecutePayPalPaymentResponses"
},
{
"operation": "getAccountSettings",
"path": "/account/settings",
"method": "GET",
"description": "This endpoint returns information related to your Account settings: Managed service subscription, Longview subscription, and network helper.\n",
"name": "GetAccountSettings",
"handlerName": "HandleGetAccountSettings",
"processorName": "GetAccountSettings",
"clientName": "GetAccountSettings",
"responsesTypeName": "GetAccountSettingsResponses"
},
{
"operation": "updateAccountSettings",
"path": "/account/settings",
"method": "PUT",
"description": "This endpoint allows you to update your Account settings.\n",
"name": "UpdateAccountSettings",
"handlerName": "HandleUpdateAccountSettings",
"processorName": "UpdateAccountSettings",
"clientName": "UpdateAccountSettings",
"parametersTypeName": "UpdateAccountSettingsParameters",
"responsesTypeName": "UpdateAccountSettingsResponses"
},
{
"operation": "getUsers",
"path": "/account/users",
"method": "GET",
"description": "Returns a paginated list of Users on your account. Users may access all or part of your account based on their restricted status and grants. An unrestricted user may access everything on the account, whereas restricted user may only access entities or perform actions they've been given specific grants to.\n",
"name": "GetUsers",
"handlerName": "HandleGetUsers",
"processorName": "GetUsers",
"clientName": "GetUsers",
"responsesTypeName": "GetUsersResponses"
},
{
"operation": "createUser",
"path": "/account/users",
"method": "POST",
"description": "Creates a new User on your account. Once created, the user will be able to log in and access portions of your account. Access is determined by whether or not they are restricted, and what grants they have been given.\n",
"name": "CreateUser",
"handlerName": "HandleCreateUser",
"processorName": "CreateUser",
"clientName": "CreateUser",
"parametersTypeName": "CreateUserParameters",
"responsesTypeName": "CreateUserResponses"
},
{
"operation": "getUser",
"path": "/account/users/{username}",
"method": "GET",
"description": "Returns information about a single user on your account.\n",
"name": "GetUser",
"handlerName": "HandleGetUser",
"processorName": "GetUser",
"clientName": "GetUser",
"responsesTypeName": "GetUserResponses"
},
{
"operation": "updateUser",
"path": "/account/users/{username}",
"method": "PUT",
"description": "Update information about a user on your account. This can be used to change the restricted status of a user. When making a user restricted, no grants will be configured by default and you must then set up grants in order for the user to access anything on the account.\n",
"name": "UpdateUser",
"handlerName": "HandleUpdateUser",
"processorName": "UpdateUser",
"clientName": "UpdateUser",
"parametersTypeName": "UpdateUserParameters",
"responsesTypeName": "UpdateUserResponses"
},
{
"operation": "deleteUser",
"path": "/account/users/{username}",
"method": "DELETE",
"description": "Deletes a user. The deleted user will be immediately logged out and may no longer log in or perform any actions. All grants that user had will be lost.\n",
"name": "DeleteUser",
"handlerName": "HandleDeleteUser",
"processorName": "DeleteUser",
"clientName": "DeleteUser",
"responsesTypeName": "DeleteUserResponses"
},
{
"operation": "getUserGrants",
"path": "/account/users/{username}/grants",
"method": "GET",
"description": "Returns the full grants structure for this user. This includes all entities on the account alongside what level of access this user has to each of them. Individual users may view their own grants at the `/profile/grants` endpoint, but will not see entities that they have no access to.\n",
"name": "GetUserGrants",
"handlerName": "HandleGetUserGrants",
"processorName": "GetUserGrants",
"clientName": "GetUserGrants",
"responsesTypeName": "GetUserGrantsResponses"
},
{
"operation": "updateUserGrants",
"path": "/account/users/{username}/grants",
"method": "PUT",
"description": "Update the grants a user has. This can be used to give a user access to new entities or actions, or take access away. You do not need to include the grant for every entity on the account in this request; any that are not included will remain unchanged.\n",
"name": "UpdateUserGrants",
"handlerName": "HandleUpdateUserGrants",
"processorName": "UpdateUserGrants",
"clientName": "UpdateUserGrants",
"parametersTypeName": "UpdateUserGrantsParameters",
"responsesTypeName": "UpdateUserGrantsResponses"
},
{
"operation": "getTransfer",
"path": "/account/transfer",
"method": "GET",
"description": "This endpoint returns a Transfer object.\n",
"name": "GetTransfer",
"handlerName": "HandleGetTransfer",
"processorName": "GetTransfer",
"clientName": "GetTransfer",
"responsesTypeName": "GetTransferResponses"
},
{
"operation": "getDomains",
"path": "/domains",
"method": "GET",
"description": "This is a collection of domains that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for these to work you must own the domains and point your registrar at Linode's nameservers.\n",
"name": "GetDomains",
"handlerName": "HandleGetDomains",
"processorName": "GetDomains",
"clientName": "GetDomains",
"responsesTypeName": "GetDomainsResponses"
},
{
"operation": "createDomain",
"path": "/domains",
"method": "POST",
"description": "Adds a new domain to Linode's DNS Manager. Linode is not a registrar, and you must own the domain before adding it here. Be sure to point your registrar to Linode's nameservers so that the records hosted here are used.\n",
"name": "CreateDomain",
"handlerName": "HandleCreateDomain",
"processorName": "CreateDomain",
"clientName": "CreateDomain",
"parametersTypeName": "CreateDomainParameters",
"responsesTypeName": "CreateDomainResponses"
},
{
"operation": "getDomain",
"path": "/domains/{domainId}",
"method": "GET",
"description": "This is a single domain that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for this domain record to work you must own the domain and point your registrar at Linode's nameservers.\n",
"name": "GetDomain",
"handlerName": "HandleGetDomain",
"processorName": "GetDomain",
"clientName": "GetDomain",
"responsesTypeName": "GetDomainResponses"
},
{
"operation": "updateDomain",
"path": "/domains/{domainId}",
"method": "PUT",
"description": "Update information about a domain in Linode's DNS Manager.\n",
"name": "UpdateDomain",
"handlerName": "HandleUpdateDomain",
"processorName": "UpdateDomain",
"clientName": "UpdateDomain",
"parametersTypeName": "UpdateDomainParameters",
"responsesTypeName": "UpdateDomainResponses"
},
{
"operation": "deleteDomain",
"path": "/domains/{domainId}",
"method": "DELETE",
"description": "Deletes a domain from Linode's DNS Manager. The domain will be removed from Linode's nameservers shortly after this operation completes. This also deletes all associated Domain Records.\n",
"name": "DeleteDomain",
"handlerName": "HandleDeleteDomain",
"processorName": "DeleteDomain",
"clientName": "DeleteDomain",
"responsesTypeName": "DeleteDomainResponses"
},
{
"operation": "getImages",
"path": "/images",
"method": "GET",
"description": "Returns a paginated list of Images. This list includes public Images and your private Images. You can call this enpoint without authentication to get all of the public Images.\n",
"name": "GetImages",
"handlerName": "HandleGetImages",
"processorName": "GetImages",
"clientName": "GetImages",
"responsesTypeName": "GetImagesResponses"
},
{
"operation": "createImage",
"path": "/images",
"method": "POST",
"description": "Creates a new private gold-master Image from a Linode Disk. There is no additional charge to store Images for Linode users, with a limit of 2GB per Image and 3 Images per account.\n",
"name": "CreateImage",
"handlerName": "HandleCreateImage",
"processorName": "CreateImage",
"clientName": "CreateImage",
"parametersTypeName": "CreateImageParameters",
"responsesTypeName": "CreateImageResponses"
},
{
"operation": "getImage",
"path": "/images/{imageId}",
"method": "GET",
"description": "Get information about a single image.\n",
"name": "GetImage",
"handlerName": "HandleGetImage",
"processorName": "GetImage",
"clientName": "GetImage",
"responsesTypeName": "GetImageResponses"
},
{
"operation": "updateImage",
"path": "/images/{imageId}",
"method": "PUT",
"description": "This allows you to update an private Image that you have permission to `read_write`.\n",
"name": "UpdateImage",
"handlerName": "HandleUpdateImage",
"processorName": "UpdateImage",
"clientName": "UpdateImage",
"parametersTypeName": "UpdateImageParameters",
"responsesTypeName": "UpdateImageResponses"
},
{
"operation": "deleteImage",
"path": "/images/{imageId}",
"method": "DELETE",
"description": "Deletes an Image you have permission to `read_write`. Deleting an image is a destructive\nprocess and cannot be undone. Only private Images are deletable.\n",
"name": "DeleteImage",
"handlerName": "HandleDeleteImage",
"processorName": "DeleteImage",
"clientName": "DeleteImage",
"responsesTypeName": "DeleteImageResponses"
},
{
"operation": "getLinodeInstaces",
"path": "/linode/instances",
"method": "GET",
"description": "Returns a paginated list of Linodes you have permission to view.\n",
"name": "GetLinodeInstaces",
"handlerName": "HandleGetLinodeInstaces",
"processorName": "GetLinodeInstaces",
"clientName": "GetLinodeInstaces",
"responsesTypeName": "GetLinodeInstacesResponses"
},
{
"operation": "createLinodeInstance",
"path": "/linode/instances",
"method": "POST",
"description": "This endpoint allows you to create a new Linode server on your account. In order for this\nrequest to complete successfully, your user must have the `add_linodes` grant. Creating a\nnew Linode will incur a charge on your account.\n\nLinodes can be created using one of the available types. See `GET /linode/types` to get more\ninformation about each type's specs and cost.\n\nLinodes can be created in any one of our available regions, see `GET /regions` for a list\nof available regions you deploy your Linode in.\n\nLinodes can be created in a number of ways:\n\n- Using a Linode Linux Distribution image or an image you created based on another Linode\n - The Linode will be `running` after it completes `provisioning`\n - A default a config with two disks, one being a 512 swap disk, is created\n - `swap_size` can be used to customize the swap disk size\n - Requires a `password` be supplied to use for the root user's account\n - It is recommended to supply ssh keys for the root user using the `authorized_keys` field\n\n- Using one of your own StackScripts or a public StackScript\n - The Linode will be `running` after it completes `provisioning`\n - Requires a compatible Linode Linux Distribution `image` to be supplied\n - see `GET /linode/stackscript/{stackscriptId}` for compatible images\n - Requires a `root_pass` be supplied to use for the root user's account\n - It is recommended to supply ssh keys for the root user using the `authorized_keys` field\n\n- Using one of your other Linode's backups\n - The Linode will be `running` after it completes `provisioning`\n - The disks and config will match that of the Linode that was backed up\n - The `root_pass` will match that of the Linode that was backed up\n\n- Create an empty Linode\n - The Linode will remain `offline` and must be manually started\n - see `POST /linode/instances/{linodeId}/boot`\n - Disks and Configs must be created manually\n - This is only recommended for advanced use-cases\n",
"name": "CreateLinodeInstance",
"handlerName": "HandleCreateLinodeInstance",
"processorName": "CreateLinodeInstance",
"clientName": "CreateLinodeInstance",
"parametersTypeName": "CreateLinodeInstanceParameters",
"responsesTypeName": "CreateLinodeInstanceResponses"
},
{
"operation": "getLinodeInstance",
"path": "/linode/instances/{linodeId}",
"method": "GET",
"description": "Get a specific Linode by ID.",
"name": "GetLinodeInstance",
"handlerName": "HandleGetLinodeInstance",
"processorName": "GetLinodeInstance",
"clientName": "GetLinodeInstance",
"responsesTypeName": "GetLinodeInstanceResponses"
},
{
"operation": "updateLinodeInstance",
"path": "/linode/instances/{linodeId}",
"method": "PUT",
"description": "This allows you to update a Linode that you have permission to `read_write`.\n",
"name": "UpdateLinodeInstance",
"handlerName": "HandleUpdateLinodeInstance",
"processorName": "UpdateLinodeInstance",
"clientName": "UpdateLinodeInstance",
"parametersTypeName": "UpdateLinodeInstanceParameters",
"responsesTypeName": "UpdateLinodeInstanceResponses"
},
{
"operation": "deleteLinodeInstance",
"path": "/linode/instances/{linodeId}",
"method": "DELETE",
"description": "Deletes a Linode you have permission to `read_write`. Deleting a Linode is a destructive\nprocess and cannot be undone. Additionally, deleting a Linode:\n\n* Gives up any IP addresses the Linode was assigned\n* Deletes all disks, backups, configs, etc.\n* Stops billing for the Linode and its associated services. You will be billed for time used\n within the billing period the Linode was active.\n",
"name": "DeleteLinodeInstance",
"handlerName": "HandleDeleteLinodeInstance",
"processorName": "DeleteLinodeInstance",
"clientName": "DeleteLinodeInstance",
"responsesTypeName": "DeleteLinodeInstanceResponses"
},
{
"operation": "getBackups",
"path": "/linode/instances/{linodeId}/backups",
"method": "GET",
"description": "Returns information about this Linode's available backups.\n",
"name": "GetBackups",
"handlerName": "HandleGetBackups",
"processorName": "GetBackups",
"clientName": "GetBackups",
"responsesTypeName": "GetBackupsResponses"
},
{
"operation": "createSnapshot",
"path": "/linode/instances/{linodeId}/backups",
"method": "POST",
"description": "Creates a snapshot backup of a Linode. WARNING: If you already have a snapshot this is a destructive operation. The previous snapshot will be deleted.\n",
"name": "CreateSnapshot",
"handlerName": "HandleCreateSnapshot",
"processorName": "CreateSnapshot",
"clientName": "CreateSnapshot",
"parametersTypeName": "CreateSnapshotParameters",
"responsesTypeName": "CreateSnapshotResponses"
},
{
"operation": "cancelBackups",
"path": "/linode/instances/{linodeId}/backups/cancel",
"method": "POST",
"description": "Cancels the backup service on the given Linode.\n",
"name": "CancelBackups",
"handlerName": "HandleCancelBackups",
"processorName": "CancelBackups",
"clientName": "CancelBackups",
"responsesTypeName": "CancelBackupsResponses"
},
{
"operation": "enableBackups",
"path": "/linode/instances/{linodeId}/backups/enable",
"method": "POST",
"description": "Enables backups for the specified Linode.\n",
"name": "EnableBackups",
"handlerName": "HandleEnableBackups",
"processorName": "EnableBackups",
"clientName": "EnableBackups",
"responsesTypeName": "EnableBackupsResponses"
},
{
"operation": "getBackup",
"path": "/linode/instances/{linodeId}/backups/{backupId}",
"method": "GET",
"description": "Return information about a backup.\n",
"name": "GetBackup",
"handlerName": "HandleGetBackup",
"processorName": "GetBackup",
"clientName": "GetBackup",
"responsesTypeName": "GetBackupResponses"
},
{
"operation": "restoreBackup",
"path": "/linode/instances/{linodeId}/backups/{backupId}/restore",
"method": "POST",
"description": "Restores a Linode's backup to the specified Linode.\n",
"name": "RestoreBackup",
"handlerName": "HandleRestoreBackup",
"processorName": "RestoreBackup",
"clientName": "RestoreBackup",
"parametersTypeName": "RestoreBackupParameters",
"responsesTypeName": "RestoreBackupResponses"
},
{
"operation": "bootLinodeInstance",
"path": "/linode/instances/{linodeId}/boot",
"method": "POST",
"description": "Boots a Linode you have permission to modify. If no parameters are given, a config profile\nwill be chosen for this boot based on the following criteria:\n\n* If there is only one config profile for this Linode, it will be used.\n* If there is more than one config profile, the last booted config will be used.\n* If there is more than one config profile and none were the last to be booted, because the\n Linode was never booted or the last booted config was deleted, an error will be returned.\n",
"name": "BootLinodeInstance",
"handlerName": "HandleBootLinodeInstance",
"processorName": "BootLinodeInstance",
"clientName": "BootLinodeInstance",
"parametersTypeName": "BootLinodeInstanceParameters",
"responsesTypeName": "BootLinodeInstanceResponses"
},
{
"operation": "rebootLinodeInstance",
"path": "/linode/instances/{linodeId}/reboot",
"method": "POST",
"description": "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.\n",
"name": "RebootLinodeInstance",
"handlerName": "HandleRebootLinodeInstance",
"processorName": "RebootLinodeInstance",
"clientName": "RebootLinodeInstance",
"responsesTypeName": "RebootLinodeInstanceResponses"
},
{
"operation": "shutdownLinodeInstance",
"path": "/linode/instances/{linodeId}/shutdown",
"method": "POST",
"description": "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.\n",
"name": "ShutdownLinodeInstance",
"handlerName": "HandleShutdownLinodeInstance",
"processorName": "ShutdownLinodeInstance",
"clientName": "ShutdownLinodeInstance",
"responsesTypeName": "ShutdownLinodeInstanceResponses"
},
{
"operation": "mutateLinodeInstance",
"path": "/linode/instances/{linodeId}/mutate",
"method": "POST",
"description": "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.\nIf any actions are currently running or queued, those actions must be completed first before you can initiate a mutate.\n",
"name": "MutateLinodeInstance",
"handlerName": "HandleMutateLinodeInstance",
"processorName": "MutateLinodeInstance",
"clientName": "MutateLinodeInstance",
"responsesTypeName": "MutateLinodeInstanceResponses"
},
{
"operation": "resizeLinodeInstance",
"path": "/linode/instances/{linodeId}/resize",
"method": "POST",
"description": "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:\n\n * Any pending free upgrades to the Linode's current type must be performed\n before a resize can occur.\n * The Linode must not have a pending migration.\n * Your account cannot have an outstanding balance.\n * The Linode must not have more disk allocation than the new type allows.\n * In that situation, you must first delete or resize the disk to be smaller.\n",
"name": "ResizeLinodeInstance",
"handlerName": "HandleResizeLinodeInstance",
"processorName": "ResizeLinodeInstance",
"clientName": "ResizeLinodeInstance",
"parametersTypeName": "ResizeLinodeInstanceParameters",
"responsesTypeName": "ResizeLinodeInstanceResponses"
},
{
"operation": "rebuildLinodeInstance",
"path": "/linode/instances/{linodeId}/rebuild",
"method": "POST",
"description": "This endpoint allows you to rebuild a Linode if you have the `read_write` permission for it. If any actions are currently running or queued, those actions must be completed first before you can initiate a rebuild.\nA 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:\n\n * Requires an `image` be supplied.\n * Requires a `root_pass` be supplied to use for the root user's account.\n * It is recommended to supply ssh keys for the root user using the\n `authorized_keys` field.\n",
"name": "RebuildLinodeInstance",
"handlerName": "HandleRebuildLinodeInstance",
"processorName": "RebuildLinodeInstance",
"clientName": "RebuildLinodeInstance",
"parametersTypeName": "RebuildLinodeInstanceParameters",
"responsesTypeName": "RebuildLinodeInstanceResponses"
},
{
"operation": "rescueLinodeInstance",
"path": "/linode/instances/{linodeId}/rescue",
"method": "POST",
"description": "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.\n* Note that \"sdh\" is reserved and unavailable during rescue.\n",
"name": "RescueLinodeInstance",
"handlerName": "HandleRescueLinodeInstance",
"processorName": "RescueLinodeInstance",
"clientName": "RescueLinodeInstance",
"parametersTypeName": "RescueLinodeInstanceParameters",
"responsesTypeName": "RescueLinodeInstanceResponses"
},
{
"operation": "cloneLinodeInstance",
"path": "/linode/instances/{linodeId}/clone",
"method": "POST",
"description": "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.\nIf cloning to an existing Linode, any actions currently running or queued must be completed first before you can clone to it.\n",
"name": "CloneLinodeInstance",
"handlerName": "HandleCloneLinodeInstance",
"processorName": "CloneLinodeInstance",
"clientName": "CloneLinodeInstance",
"parametersTypeName": "CloneLinodeInstanceParameters",
"responsesTypeName": "CloneLinodeInstanceResponses"
},
{
"operation": "getLinodeIPs",
"path": "/linode/instances/{linodeId}/ips",
"method": "GET",
"description": "Returns networking information for a single Linode.\n",
"name": "GetLinodeIPs",
"handlerName": "HandleGetLinodeIPs",
"processorName": "GetLinodeIPs",
"clientName": "GetLinodeIPs",
"responsesTypeName": "GetLinodeIPsResponses"
},
{
"operation": "addLinodeIP",
"path": "/linode/instances/{linodeId}/ips",
"method": "POST",
"description": "Allocate a public or private IPv4 address to a Linode. Public IP Addresses, over and above 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 ticket. One may not add more than one private IPv4 address to a single Linode.\n",
"name": "AddLinodeIP",
"handlerName": "HandleAddLinodeIP",
"processorName": "AddLinodeIP",
"clientName": "AddLinodeIP",
"responsesTypeName": "AddLinodeIPResponses"
},
{
"operation": "getLinodeIP",
"path": "/linode/instances/{linodeId}/ips/{address}",
"method": "GET",
"description": "View information about the specified IP address associated with the specified Linode.\n",
"name": "GetLinodeIP",
"handlerName": "HandleGetLinodeIP",
"processorName": "GetLinodeIP",
"clientName": "GetLinodeIP",
"responsesTypeName": "GetLinodeIPResponses"
},
{
"operation": "updateLinodeIP",
"path": "/linode/instances/{linodeId}/ips/{address}",
"method": "PUT",
"description": "Manage a particular IP Address associated with this Linode. Currently only allows setting/resetting reverse DNS.\n",
"name": "UpdateLinodeIP",
"handlerName": "HandleUpdateLinodeIP",
"processorName": "UpdateLinodeIP",
"clientName": "UpdateLinodeIP",
"parametersTypeName": "UpdateLinodeIPParameters",
"responsesTypeName": "UpdateLinodeIPResponses"
},
{
"operation": "removeLinodeIP",
"path": "/linode/instances/{linodeId}/ips/{address}",
"method": "DELETE",
"description": "Delete a public IPv4 address associated with this Linode. This will fail if it is the Linode's last remaining IP address. Private IPv4 addresses cannot be removed via this endpoint.\n",
"name": "RemoveLinodeIP",
"handlerName": "HandleRemoveLinodeIP",
"processorName": "RemoveLinodeIP",
"clientName": "RemoveLinodeIP",
"responsesTypeName": "RemoveLinodeIPResponses"
},
{
"operation": "getLinodeVolumes",
"path": "/linode/instances/{linodeId}/volumes",
"method": "GET",
"description": "View Block Storage Volumes attached to this Linode.\n",
"name": "GetLinodeVolumes",
"handlerName": "HandleGetLinodeVolumes",
"processorName": "GetLinodeVolumes",
"clientName": "GetLinodeVolumes",
"responsesTypeName": "GetLinodeVolumesResponses"
},
{
"operation": "getLinodeConfigs",
"path": "/linode/instances/{linodeId}/configs",
"method": "GET",
"description": "Lists configuration profiles associated with a Linode.\n",
"name": "GetLinodeConfigs",
"handlerName": "HandleGetLinodeConfigs",
"processorName": "GetLinodeConfigs",
"clientName": "GetLinodeConfigs",
"responsesTypeName": "GetLinodeConfigsResponses"
},
{
"operation": "addLinodeConfig",
"path": "/linode/instances/{linodeId}/configs",
"method": "POST",
"description": "Adds a new configuration profile to a Linode.\n",
"name": "AddLinodeConfig",
"handlerName": "HandleAddLinodeConfig",
"processorName": "AddLinodeConfig",
"clientName": "AddLinodeConfig",
"parametersTypeName": "AddLinodeConfigParameters",
"responsesTypeName": "AddLinodeConfigResponses"
},
{
"operation": "getLinodeConfig",
"path": "/linode/instances/{linodeId}/configs/{configId}",
"method": "GET",
"description": "Returns information about a specific configuration profile.\n",
"name": "GetLinodeConfig",
"handlerName": "HandleGetLinodeConfig",
"processorName": "GetLinodeConfig",
"clientName": "GetLinodeConfig",
"responsesTypeName": "GetLinodeConfigResponses"
},
{
"operation": "updateLinodeConfig",
"path": "/linode/instances/{linodeId}/configs/{configId}",
"method": "PUT",
"description": "Updates the parameters of a single configuration profile.\n",
"name": "UpdateLinodeConfig",
"handlerName": "HandleUpdateLinodeConfig",
"processorName": "UpdateLinodeConfig",
"clientName": "UpdateLinodeConfig",
"parametersTypeName": "UpdateLinodeConfigParameters",
"responsesTypeName": "UpdateLinodeConfigResponses"
},
{
"path": "/linode/instances/{linodeId}/configs/{configId}",
"method": "DELETE",
"description": "Deletes the specified configuration profile from the specified Linode.\n",
"name": "DELETE_linode_instances_linodeId_configs_configId",
"handlerName": "HandleDELETE_linode_instances_linodeId_configs_configId",
"processorName": "DELETE_linode_instances_linodeId_configs_configId",
"clientName": "DELETE_linode_instances_linodeId_configs_configId",
"responsesTypeName": "DELETE_linode_instances_linodeId_configs_configIdResponses"
},
{
"operation": "getLinodeDisks",
"path": "/linode/instances/{linodeId}/disks",
"method": "GET",
"description": "View Disk information for disks associated with this Linode.\n",
"name": "GetLinodeDisks",
"handlerName": "HandleGetLinodeDisks",
"processorName": "GetLinodeDisks",
"clientName": "GetLinodeDisks",
"responsesTypeName": "GetLinodeDisksResponses"
},
{
"operation": "addLinodeDisk",
"path": "/linode/instances/{linodeId}/disks",
"method": "POST",
"description": "Adds a new disk to a Linode. You can optionally create a disk from an image (see `GET /images` for a list of available public images, or use one of your own), and optionally provide a StackScript to deploy with this Disk.\n",
"name": "AddLinodeDisk",
"handlerName": "HandleAddLinodeDisk",
"processorName": "AddLinodeDisk",
"clientName": "AddLinodeDisk",
"parametersTypeName": "AddLinodeDiskParameters",
"responsesTypeName": "AddLinodeDiskResponses"
},
{
"operation": "getLinodeDisk",
"path": "/linode/instances/{linodeId}/disks/{diskId}",
"method": "GET",
"description": "View Disk information for a disk associated with this Linode.\n",
"name": "GetLinodeDisk",
"handlerName": "HandleGetLinodeDisk",
"processorName": "GetLinodeDisk",
"clientName": "GetLinodeDisk",
"responsesTypeName": "GetLinodeDiskResponses"
},
{
"operation": "updateDisk",
"path": "/linode/instances/{linodeId}/disks/{diskId}",
"method": "PUT",
"description": "This allows you to update a Disk that you have permission to `read_write`.\n",
"name": "UpdateDisk",
"handlerName": "HandleUpdateDisk",
"processorName": "UpdateDisk",
"clientName": "UpdateDisk",
"parametersTypeName": "UpdateDiskParameters",
"responsesTypeName": "UpdateDiskResponses"
},
{
"operation": "deleteDisk",
"path": "/linode/instances/{linodeId}/disks/{diskId}",
"method": "DELETE",
"description": "Deletes a Disk you have permission to `read_write`. Deleting a Disk is a\ndestructive process and cannot be undone.\n",
"name": "DeleteDisk",
"handlerName": "HandleDeleteDisk",
"processorName": "DeleteDisk",
"clientName": "DeleteDisk",
"responsesTypeName": "DeleteDiskResponses"
},
{
"operation": "resetDiskPassword",
"path": "/linode/instances/{linodeId}/disks/{diskId}/password",
"method": "POST",
"description": "This endpoint allows you to reset the password of a disk you have permission to `read_write`.\n",
"name": "ResetDiskPassword",
"handlerName": "HandleResetDiskPassword",
"processorName": "ResetDiskPassword",
"clientName": "ResetDiskPassword",
"parametersTypeName": "ResetDiskPasswordParameters",
"responsesTypeName": "ResetDiskPasswordResponses"
},
{
"operation": "resizeDisk",
"path": "/linode/instances/{linodeId}/disks/{diskId}/resize",
"method": "POST",
"description": "This endpoint allows you to resize a disk you have permission to `read_write`.\nThe Linode this Disk is attached to must be shut down for resizing to take effect.\nIf 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.\n",
"name": "ResizeDisk",
"handlerName": "HandleResizeDisk",
"processorName": "ResizeDisk",
"clientName": "ResizeDisk",
"parametersTypeName": "ResizeDiskParameters",
"responsesTypeName": "ResizeDiskResponses"
},
{
"operation": "getLinodeStats",
"path": "/linode/instances/{linodeId}/stats",
"method": "GET",
"description": "This endpoint returns CPU, IO, IPv4, and IPv6 statistics for your Linode for the past 24 hours.\n",
"name": "GetLinodeStats",
"handlerName": "HandleGetLinodeStats",
"processorName": "GetLinodeStats",
"clientName": "GetLinodeStats",
"responsesTypeName": "GetLinodeStatsResponses"
},
{
"operation": "getLinodeStatsByYearMonth",
"path": "/linode/instances/{linodeId}/stats/{year}/{month}",
"method": "GET",
"description": "This endpoint 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.\n",
"name": "GetLinodeStatsByYearMonth",
"handlerName": "HandleGetLinodeStatsByYearMonth",
"processorName": "GetLinodeStatsByYearMonth",
"clientName": "GetLinodeStatsByYearMonth",
"responsesTypeName": "GetLinodeStatsByYearMonthResponses"
},
{
"operation": "getKernels",
"path": "/linode/kernels",
"method": "GET",
"description": "Lists available kernels.\n",
"name": "GetKernels",
"handlerName": "HandleGetKernels",
"processorName": "GetKernels",
"clientName": "GetKernels",
"responsesTypeName": "GetKernelsResponses"
},
{
"operation": "getKernel",
"path": "/linode/kernels/{kernelId}",
"method": "GET",
"description": "Get information about a single kernel.\n",
"name": "GetKernel",
"handlerName": "HandleGetKernel",
"processorName": "GetKernel",
"clientName": "GetKernel",
"responsesTypeName": "GetKernelResponses"
},
{
"operation": "getStackScripts",
"path": "/linode/stackscripts",
"method": "GET",
"description": "Returns a list of publicly available StackScripts. If the request is authenticated, the list also includes private StackScripts the user has permissions to view.\n",
"name": "GetStackScripts",
"handlerName": "HandleGetStackScripts",
"processorName": "GetStackScripts",
"clientName": "GetStackScripts",
"responsesTypeName": "GetStackScriptsResponses"
},
{
"operation": "addStackScript",
"path": "/linode/stackscripts",
"method": "POST",
"description": "This endpoint allows you to add a new StackScript to your account.\n",
"name": "AddStackScript",
"handlerName": "HandleAddStackScript",
"processorName": "AddStackScript",
"clientName": "AddStackScript",
"parametersTypeName": "AddStackScriptParameters",
"responsesTypeName": "AddStackScriptResponses"
},
{
"operation": "getStackScript",
"path": "/linode/stackscripts/{stackscriptId}",
"method": "GET",
"description": "This endpoint returns all of the information about a specified StackScript, including the contents of the script.\n",
"name": "GetStackScript",
"handlerName": "HandleGetStackScript",
"processorName": "GetStackScript",
"clientName": "GetStackScript",
"responsesTypeName": "GetStackScriptResponses"
},
{
"operation": "updateStackScript",
"path": "/linode/stackscripts/{stackscriptId}",
"method": "PUT",
"description": "This endpoint allows you to modify a StackScript. Setting a StackScript to public is a permanent change.\n",
"name": "UpdateStackScript",
"handlerName": "HandleUpdateStackScript",
"processorName": "UpdateStackScript",
"clientName": "UpdateStackScript",
"responsesTypeName": "UpdateStackScriptResponses"
},
{
"operation": "deleteStackScript",
"path": "/linode/stackscripts/{stackscriptId}",
"method": "DELETE",
"description": "This endpoint allows you to permanently delete a specific StackScript. You cannot delete a public StackScript.\n",
"name": "DeleteStackScript",
"handlerName": "HandleDeleteStackScript",
"processorName": "DeleteStackScript",
"clientName": "DeleteStackScript",
"responsesTypeName": "DeleteStackScriptResponses"
},
{
"operation": "getLinodeTypes",
"path": "/linode/types",
"method": "GET",
"description": "Returns collection of Linode types, including pricing and specifications for each type. These are used when creating or resizing Linodes.\n",
"name": "GetLinodeTypes",
"handlerName": "HandleGetLinodeTypes",
"processorName": "GetLinodeTypes",
"clientName": "GetLinodeTypes",
"responsesTypeName": "GetLinodeTypesResponses"
},
{
"operation": "getLinodeType",
"path": "/linode/types/{typeId}",
"method": "GET",
"description": "Returns information about a specific Linode type, including pricing and specifications. This is used when creating or resizing a Linode.\n",
"name": "GetLinodeType",
"handlerName": "HandleGetLinodeType",
"processorName": "GetLinodeType",
"clientName": "GetLinodeType",
"responsesTypeName": "GetLinodeTypeResponses"
},
{
"operation": "getManagedContacts",
"path": "/managed/contacts",
"method": "GET",
"description": "Returns a paginated list of Managed Contacts on your account.\n",
"name": "GetManagedContacts",
"handlerName": "HandleGetManagedContacts",
"processorName": "GetManagedContacts",
"clientName": "GetManagedContacts",
"responsesTypeName": "GetManagedContactsResponses"
},
{
"operation": "createManagedContact",
"path": "/managed/contacts",
"method": "POST",
"description": "Creates a new Managed Contact. A Managed Contact is someone Linode special forces can contact in the course of attempting to resolve an issue with a Managed Service.\n",
"name": "CreateManagedContact",
"handlerName": "HandleCreateManagedContact",
"processorName": "CreateManagedContact",
"clientName": "CreateManagedContact",
"parametersTypeName": "CreateManagedContactParameters",
"responsesTypeName": "CreateManagedContactResponses"
},
{
"operation": "getManagedContact",
"path": "/managed/contacts/{contactId}",
"method": "GET",
"description": "Returns a single Managed Contact.\n",
"name": "GetManagedContact",
"handlerName": "HandleGetManagedContact",
"processorName": "GetManagedContact",
"clientName": "GetManagedContact",
"responsesTypeName": "GetManagedContactResponses"
},
{
"operation": "updateManagedContact",
"path": "/managed/contacts/{contactId}",
"method": "PUT",
"description": "Updates information about a Managed Contact.\n",
"name": "UpdateManagedContact",
"handlerName": "HandleUpdateManagedContact",
"processorName": "UpdateManagedContact",
"clientName": "UpdateManagedContact",
"parametersTypeName": "UpdateManagedContactParameters",
"responsesTypeName": "UpdateManagedContactResponses"
},
{
"operation": "deleteManagedContact",
"path": "/managed/contacts/{contactId}",
"method": "DELETE",
"description": "Deletes a Managed Contact.\n",
"name": "DeleteManagedContact",
"handlerName": "HandleDeleteManagedContact",
"processorName": "DeleteManagedContact",
"clientName": "DeleteManagedContact",
"responsesTypeName": "DeleteManagedContactResponses"
},
{
"operation": "getManagedCredentials",
"path": "/managed/credentials",
"method": "GET",
"description": "Returns a paginated list of Managed Credentials on your account.\n",
"name": "GetManagedCredentials",
"handlerName": "HandleGetManagedCredentials",
"processorName": "GetManagedCredentials",
"clientName": "GetManagedCredentials",
"responsesTypeName": "GetManagedCredentialsResponses"
},
{
"operation": "createManagedCredential",
"path": "/managed/credentials",
"method": "POST",
"description": "Creates a new Managed Credential. A Managed Credential is stored securely to allow Linode special forces to access your Managed Services and resolve issues.\n",
"name": "CreateManagedCredential",
"handlerName": "HandleCreateManagedCredential",
"processorName": "CreateManagedCredential",
"clientName": "CreateManagedCredential",
"parametersTypeName": "CreateManagedCredentialParameters",
"responsesTypeName": "CreateManagedCredentialResponses"
},
{
"operation": "getManagedCredential",
"path": "/managed/credentials/{credentialId}",
"method": "GET",
"description": "Returns a single Managed Credential.\n",
"name": "GetManagedCredential",
"handlerName": "HandleGetManagedCredential",
"processorName": "GetManagedCredential",
"clientName": "GetManagedCredential",
"responsesTypeName": "GetManagedCredentialResponses"
},
{
"operation": "updateManagedCredential",
"path": "/managed/credentials/{credentialId}",
"method": "PUT",
"description": "Updates information about a Managed Credential.\n",
"name": "UpdateManagedCredential",
"handlerName": "HandleUpdateManagedCredential",
"processorName": "UpdateManagedCredential",
"clientName": "UpdateManagedCredential",
"parametersTypeName": "UpdateManagedCredentialParameters",
"responsesTypeName": "UpdateManagedCredentialResponses"
},
{
"operation": "deleteManagedCredential",
"path": "/managed/credentials/{credentialId}",
"method": "DELETE",
"description": "Deletes a Managed Credential. Linode special forces will no longer have access to this credential when attempting to resolve issues.\n",
"name": "DeleteManagedCredential",
"handlerName": "HandleDeleteManagedCredential",
"processorName": "DeleteManagedCredential",
"clientName": "DeleteManagedCredential",
"responsesTypeName": "DeleteManagedCredentialResponses"
},
{
"operation": "getManagedIssues",
"path": "/managed/issues",
"method": "GET",
"description": "Returns a paginated list of recent and ongoing issues detected on your Managed Services.\n",
"name": "GetManagedIssues",
"handlerName": "HandleGetManagedIssues",
"processorName": "GetManagedIssues",
"clientName": "GetManagedIssues",
"responsesTypeName": "GetManagedIssuesResponses"
},
{
"operation": "getManagedIssue",
"path": "/managed/issues/{issueId}",
"method": "GET",
"description": "Returns a single issue that is impacting or did impact one of your Managed Services.\n",
"name": "GetManagedIssue",
"handlerName": "HandleGetManagedIssue",
"processorName": "GetManagedIssue",
"clientName": "GetManagedIssue",
"responsesTypeName": "GetManagedIssueResponses"
},
{
"operation": "getManagedLinodeSettings",
"path": "/managed/linode-settings",
"method": "GET",
"description": "Returns a paginated list of Managed settings for your Linodes. There will be one entry per Linode on your account.\n",
"name": "GetManagedLinodeSettings",
"handlerName": "HandleGetManagedLinodeSettings",
"processorName": "GetManagedLinodeSettings",
"clientName": "GetManagedLinodeSettings",
"responsesTypeName": "GetManagedLinodeSettingsResponses"
},
{
"operation": "getManagedLinodeSetting",
"path": "/managed/linode-settings/{linodeId}",
"method": "GET",
"description": "Returns a single Linode's Managed settings.\n",
"name": "GetManagedLinodeSetting",
"handlerName": "HandleGetManagedLinodeSetting",
"processorName": "GetManagedLinodeSetting",
"clientName": "GetManagedLinodeSetting",
"responsesTypeName": "GetManagedLinodeSettingResponses"
},
{
"operation": "updateManagedLinodeSetting",
"path": "/managed/linode-settings/{linodeId}",
"method": "PUT",
"description": "Updates a single Linode's Managed settings.\n",
"name": "UpdateManagedLinodeSetting",
"handlerName": "HandleUpdateManagedLinodeSetting",
"processorName": "UpdateManagedLinodeSetting",
"clientName": "UpdateManagedLinodeSetting",
"parametersTypeName": "UpdateManagedLinodeSettingParameters",
"responsesTypeName": "UpdateManagedLinodeSettingResponses"
},
{
"operation": "getManagedServices",
"path": "/managed/services",
"method": "GET",
"description": "Returns a paginated list of Managed Services on your account. These are the services Linode Managed is monitoring and will report and attempt to resolve issues with.\n",
"name": "GetManagedServices",
"handlerName": "HandleGetManagedServices",
"processorName": "GetManagedServices",
"clientName": "GetManagedServices",
"responsesTypeName": "GetManagedServicesResponses"
},
{
"operation": "createManagedService",
"path": "/managed/services",
"method": "POST",
"description": "Creates a new Managed Service. Linode Managed will being monitoring this service and reporting and attempting to resolve any issues.\n",
"name": "CreateManagedService",
"handlerName": "HandleCreateManagedService",
"processorName": "CreateManagedService",
"clientName": "CreateManagedService",
"parametersTypeName": "CreateManagedServiceParameters",
"responsesTypeName": "CreateManagedServiceResponses"
},
{
"operation": "getManagedService",
"path": "/managed/services/{serviceId}",
"method": "GET",
"description": "Returns information about a single Managed Service on your account.\n",
"name": "GetManagedService",
"handlerName": "HandleGetManagedService",
"processorName": "GetManagedService",
"clientName": "GetManagedService",
"responsesTypeName": "GetManagedServiceResponses"
},
{
"operation": "updateManagedService",
"path": "/managed/services/{serviceId}",
"method": "PUT",
"description": "Updates information about a Managed Service.\n",
"name": "UpdateManagedService",
"handlerName": "HandleUpdateManagedService",
"processorName": "UpdateManagedService",
"clientName": "UpdateManagedService",
"parametersTypeName": "UpdateManagedServiceParameters",
"responsesTypeName": "UpdateManagedServiceResponses"
},
{
"operation": "deleteManagedService",
"path": "/managed/services/{serviceId}",
"method": "DELETE",
"description": "Deletes a Managed Service. This service will no longer be monitored by Linode Managed.\n",
"name": "DeleteManagedService",
"handlerName": "HandleDeleteManagedService",
"processorName": "DeleteManagedService",
"clientName": "DeleteManagedService",
"responsesTypeName": "DeleteManagedServiceResponses"
},
{
"operation": "disableManagedService",
"path": "/managed/services/{serviceId}/disable",
"method": "GET",
"description": "Temporarily disables monitoring of a Managed Service.\n",
"name": "DisableManagedService",
"handlerName": "HandleDisableManagedService",
"processorName": "DisableManagedService",
"clientName": "DisableManagedService",
"responsesTypeName": "DisableManagedServiceResponses"
},
{
"operation": "enableManagedService",
"path": "/managed/services/{serviceId}/enable",
"method": "GET",
"description": "Re-enables monitoring of a Managed Service.\n",
"name": "EnableManagedService",
"handlerName": "HandleEnableManagedService",
"processorName": "EnableManagedService",
"clientName": "EnableManagedService",
"responsesTypeName": "EnableManagedServiceResponses"
},
{
"operation": "getIPs",
"path": "/networking/ips",
"method": "GET",
"description": "Returns a paginated list of IP Addresses on your account, excluding private addresses.\n",
"name": "GetIPs",
"handlerName": "HandleGetIPs",
"processorName": "GetIPs",
"clientName": "GetIPs",
"responsesTypeName": "GetIPsResponses"
},
{
"operation": "allocateIP",
"path": "/networking/ips",
"method": "POST",
"description": "Allocates a new IP Address on your account. Currently, only IPv4 addresses may be allocated this way. The Linode you are allocating this address for must be allowed to allocate additional addresses - please open a support ticket requesting additional addresses before attempting allocation.\n",
"name": "AllocateIP",
"handlerName": "HandleAllocateIP",
"processorName": "AllocateIP",
"clientName": "AllocateIP",
"parametersTypeName": "AllocateIPParameters",
"responsesTypeName": "AllocateIPResponses"
},
{
"operation": "getIP",
"path": "/networking/ips/{address}",
"method": "GET",
"description": "Returns information about a single IP Address on your account.\n",
"name": "GetIP",
"handlerName": "HandleGetIP",
"processorName": "GetIP",
"clientName": "GetIP",
"responsesTypeName": "GetIPResponses"
},
{
"operation": "updateIP",
"path": "/networking/ips/{address}",
"method": "PUT",
"description": "Sets RDNS on an IP Address. Forward DNS must already be set up for reverse DNS to be applied. If you set the RDNS to `null` for public ipv4 addresses, it will be reset to the default members.linode.com RDNS value.\n",
"name": "UpdateIP",
"handlerName": "HandleUpdateIP",
"processorName": "UpdateIP",
"clientName": "UpdateIP",
"parametersTypeName": "UpdateIPParameters",
"responsesTypeName": "UpdateIPResponses"
},
{
"operation": "getLongviewClients",
"path": "/longview/clients",
"method": "GET",
"description": "Returns a paginated list of Longview Clients you have access to. Longview Clients are used to monitor stats on your servers with the help of the Longview Client application.\n",
"name": "GetLongviewClients",
"handlerName": "HandleGetLongviewClients",
"processorName": "GetLongviewClients",
"clientName": "GetLongviewClients",
"responsesTypeName": "GetLongviewClientsResponses"
},
{
"operation": "createLongviewClient",
"path": "/longview/clients",
"method": "POST",
"description": "Create a new Longview Client. This client will not begin monitoring the status of one of your servers until you configure the Longview Client application on your server using the returning `install_code` and `api_key`.\n",
"name": "CreateLongviewClient",
"handlerName": "HandleCreateLongviewClient",
"processorName": "CreateLongviewClient",
"clientName": "CreateLongviewClient",
"parametersTypeName": "CreateLongviewClientParameters",
"responsesTypeName": "CreateLongviewClientResponses"
},
{
"operation": "getLongviewClient",
"path": "/longview/clients/{clientId}",
"method": "GET",
"description": "Returns a single Longview Client you can access.\n",
"name": "GetLongviewClient",
"handlerName": "HandleGetLongviewClient",
"processorName": "GetLongviewClient",
"clientName": "GetLongviewClient",
"responsesTypeName": "GetLongviewClientResponses"
},
{
"operation": "updateLongviewClient",
"path": "/longview/clients/{clientId}",
"method": "PUT",
"description": "Updates a Longview Client. This cannot update how it monitors your server - use the Longview Client application on your server for monitoring configuration.\n",
"name": "UpdateLongviewClient",
"handlerName": "HandleUpdateLongviewClient",
"processorName": "UpdateLongviewClient",
"clientName": "UpdateLongviewClient",
"parametersTypeName": "UpdateLongviewClientParameters",
"responsesTypeName": "UpdateLongviewClientResponses"
},
{
"operation": "deleteLongviewClient",
"path": "/longview/clients/{clientId}",
"method": "DELETE",
"description": "Deletes a Longview Client from your account. All information stored for this client will be lost. This _does not_ uninstall the Longview Client application for your server - you must do that manually.\n",
"name": "DeleteLongviewClient",
"handlerName": "HandleDeleteLongviewClient",
"processorName": "DeleteLongviewClient",
"clientName": "DeleteLongviewClient",
"responsesTypeName": "DeleteLongviewClientResponses"
},
{
"operation": "getLongviewSubscriptions",
"path": "/longview/subscriptions",
"method": "GET",
"description": "Returns a paginated list of available Longview Subscriptions. This is a public endpoint, and requires no authentication.\n",
"name": "GetLongviewSubscriptions",
"handlerName": "HandleGetLongviewSubscriptions",
"processorName": "GetLongviewSubscriptions",
"clientName": "GetLongviewSubscriptions",
"responsesTypeName": "GetLongviewSubscriptionsResponses"
},
{
"operation": "getLongviewSubscription",
"path": "/longview/subscriptions/{subscriptionId}",
"method": "GET",
"description": "Returns a single LongviewSubscription object. This is a public endpoint and requires no authentication.\n",
"name": "GetLongviewSubscription",
"handlerName": "HandleGetLongviewSubscription",
"processorName": "GetLongviewSubscription",
"clientName": "GetLongviewSubscription",
"responsesTypeName": "GetLongviewSubscriptionResponses"
},
{
"operation": "assignIPs",
"path": "/networking/ipv4/assign",
"method": "POST",
"description": "Assign multiple IPs to multiple Linodes in one region. This allows swapping, shuffling, or otherwise reorganizing v4 IP Addresses to your Linodes. When the assignment is finished, all Linodes must end up with at least one public ipv4 and no more than one private ipv4.\n",
"name": "AssignIPs",
"handlerName": "HandleAssignIPs",
"processorName": "AssignIPs",
"clientName": "AssignIPs",
"parametersTypeName": "AssignIPsParameters",
"responsesTypeName": "AssignIPsResponses"
},
{
"operation": "shareIPs",
"path": "/networking/ipv4/share",
"method": "POST",
"description": "Configure shared IPs. A shared IP may be brought up on a Linode other than the one it lists in its response. This can be used to allow one Linode to begin serving requests should another become unresponsive.\n",
"name": "ShareIPs",
"handlerName": "HandleShareIPs",
"processorName": "ShareIPs",
"clientName": "ShareIPs",
"parametersTypeName": "ShareIPsParameters",
"responsesTypeName": "ShareIPsResponses"
},
{
"operation": "getIPv6Pools",
"path": "/networking/ipv6/pools",
"method": "GET",
"description": "Displays the IPv6 pools on your account.\n",
"name": "GetIPv6Pools",
"handlerName": "HandleGetIPv6Pools",
"processorName": "GetIPv6Pools",
"clientName": "GetIPv6Pools",
"responsesTypeName": "GetIPv6PoolsResponses"
},
{
"operation": "getIPv6Ranges",
"path": "/networking/ipv6/ranges",
"method": "GET",
"description": "Displays the IPv6 ranges on your account.\n",
"name": "GetIPv6Ranges",
"handlerName": "HandleGetIPv6Ranges",
"processorName": "GetIPv6Ranges",
"clientName": "GetIPv6Ranges",
"responsesTypeName": "GetIPv6RangesResponses"
},
{
"operation": "getNodeBalancers",
"path": "/nodebalancers",
"method": "GET",
"description": "Returns a paginated list of NodeBalancers you have access to.\n",
"name": "GetNodeBalancers",
"handlerName": "HandleGetNodeBalancers",
"processorName": "GetNodeBalancers",
"clientName": "GetNodeBalancers",
"responsesTypeName": "GetNodeBalancersResponses"
},
{
"operation": "createNodeBalancer",
"path": "/nodebalancers",
"method": "POST",
"description": "Creates a new NodeBalancer in the requested region. This NodeBalancer will not start serving requests until it is configured.\n",
"name": "CreateNodeBalancer",
"handlerName": "HandleCreateNodeBalancer",
"processorName": "CreateNodeBalancer",
"clientName": "CreateNodeBalancer",
"parametersTypeName": "CreateNodeBalancerParameters",
"responsesTypeName": "CreateNodeBalancerResponses"
},
{
"operation": "getNodeBalancer",
"path": "/nodebalancers/{nodeBalancerId}",
"method": "GET",
"description": "Returns a single NodeBalancer you can access.\n",
"name": "GetNodeBalancer",
"handlerName": "HandleGetNodeBalancer",
"processorName": "GetNodeBalancer",
"clientName": "GetNodeBalancer",
"responsesTypeName": "GetNodeBalancerResponses"
},
{
"operation": "updateNodeBalancer",
"path": "/nodebalancers/{nodeBalancerId}",
"method": "PUT",
"description": "Update information about a NodeBalancer you can access.\n",
"name": "UpdateNodeBalancer",
"handlerName": "HandleUpdateNodeBalancer",
"processorName": "UpdateNodeBalancer",
"clientName": "UpdateNodeBalancer",
"parametersTypeName": "UpdateNodeBalancerParameters",
"responsesTypeName": "UpdateNodeBalancerResponses"
},
{
"operation": "deleteNodeBalancer",
"path": "/nodebalancers/{nodeBalancerId}",
"method": "DELETE",
"description": "Deletes a NodeBalancer. This cannot be undone. Deleting a NodeBalancer will also delete all associated configs and nodes, although the backend servers represented by the nodes will not be changed or removed. Deleting a NodeBalancer will cause you to lose access to the IP Addresses that NodeBalancer was assigned.\n",
"name": "DeleteNodeBalancer",
"handlerName": "HandleDeleteNodeBalancer",
"processorName": "DeleteNodeBalancer",
"clientName": "DeleteNodeBalancer",
"responsesTypeName": "DeleteNodeBalancerResponses"
},
{
"operation": "getNodeBalancerConfigs",
"path": "/nodebalancers/{nodeBalancerId}/configs",
"method": "GET",
"description": "Returns a paginated list of NodeBalancerConfigs associated with this NodeBalancer. NodeBalancer configs represent individual ports that this NodeBalancer will accept traffic on, one config per port. For example, if you wanted to accept standard http traffic, you would need a config listening on port 80.\n",
"name": "GetNodeBalancerConfigs",
"handlerName": "HandleGetNodeBalancerConfigs",
"processorName": "GetNodeBalancerConfigs",
"clientName": "GetNodeBalancerConfigs",
"responsesTypeName": "GetNodeBalancerConfigsResponses"
},
{
"operation": "createaNodeBalancerConfig",
"path": "/nodebalancers/{nodeBalancerId}/configs",
"method": "POST",
"description": "Creates a new NodeBalancerConfig, which allows the NodeBalancer to accept traffic on a new port. You will need to add NodeBalancerNodes to the new config before it can actually serve requests.\n",
"name": "CreateaNodeBalancerConfig",
"handlerName": "HandleCreateaNodeBalancerConfig",
"processorName": "CreateaNodeBalancerConfig",
"clientName": "CreateaNodeBalancerConfig",
"parametersTypeName": "CreateaNodeBalancerConfigParameters",
"responsesTypeName": "CreateaNodeBalancerConfigResponses"
},
{
"operation": "getNodeBalancerConfig",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}",
"method": "GET",
"description": "Returns configuration information for a single port of this NodeBalancer.\n",
"name": "GetNodeBalancerConfig",
"handlerName": "HandleGetNodeBalancerConfig",
"processorName": "GetNodeBalancerConfig",
"clientName": "GetNodeBalancerConfig",
"responsesTypeName": "GetNodeBalancerConfigResponses"
},
{
"operation": "updateNodeBalancerConfig",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}",
"method": "PUT",
"description": "Update the configuration for a single port on a NodeBalancer.\n",
"name": "UpdateNodeBalancerConfig",
"handlerName": "HandleUpdateNodeBalancerConfig",
"processorName": "UpdateNodeBalancerConfig",
"clientName": "UpdateNodeBalancerConfig",
"parametersTypeName": "UpdateNodeBalancerConfigParameters",
"responsesTypeName": "UpdateNodeBalancerConfigResponses"
},
{
"operation": "deleteNodeBalancerConfig",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}",
"method": "DELETE",
"description": "Deletes the configuration for a port of this NodeBalancer. This cannot be undone. Once completed, this NodeBalancer will no longer respond to requests on the given port. This also deletes all associated NodeBalancerNodes, but the Linodes they were routing traffic to are unchanged and not removed.\n",
"name": "DeleteNodeBalancerConfig",
"handlerName": "HandleDeleteNodeBalancerConfig",
"processorName": "DeleteNodeBalancerConfig",
"clientName": "DeleteNodeBalancerConfig",
"responsesTypeName": "DeleteNodeBalancerConfigResponses"
},
{
"operation": "getNodeBalancerConfigNodes",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes",
"method": "GET",
"description": "Returns a paginated list of NodeBalancer nodes associated with this config. These are the backends that will be sent traffic for this port.\n",
"name": "GetNodeBalancerConfigNodes",
"handlerName": "HandleGetNodeBalancerConfigNodes",
"processorName": "GetNodeBalancerConfigNodes",
"clientName": "GetNodeBalancerConfigNodes",
"responsesTypeName": "GetNodeBalancerConfigNodesResponses"
},
{
"operation": "createNodeBalancerNode",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes",
"method": "POST",
"description": "Creates a new NodeBalancer node, a backend that can accept traffic, for this NodeBalancer config. Nodes are routed requests on the configured port based on their status.\n",
"name": "CreateNodeBalancerNode",
"handlerName": "HandleCreateNodeBalancerNode",
"processorName": "CreateNodeBalancerNode",
"clientName": "CreateNodeBalancerNode",
"parametersTypeName": "CreateNodeBalancerNodeParameters",
"responsesTypeName": "CreateNodeBalancerNodeResponses"
},
{
"operation": "getNodeBalancerNode",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes/{nodeId}",
"method": "GET",
"description": "Returns information about a single node, a backend for this NodeBalancer's configured port.\n",
"name": "GetNodeBalancerNode",
"handlerName": "HandleGetNodeBalancerNode",
"processorName": "GetNodeBalancerNode",
"clientName": "GetNodeBalancerNode",
"responsesTypeName": "GetNodeBalancerNodeResponses"
},
{
"operation": "updateNodeBalancerNode",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes/{nodeId}",
"method": "PUT",
"description": "Updates information about a node, a backend for this NodeBalancer's configured port.\n",
"name": "UpdateNodeBalancerNode",
"handlerName": "HandleUpdateNodeBalancerNode",
"processorName": "UpdateNodeBalancerNode",
"clientName": "UpdateNodeBalancerNode",
"parametersTypeName": "UpdateNodeBalancerNodeParameters",
"responsesTypeName": "UpdateNodeBalancerNodeResponses"
},
{
"operation": "deleteNodeBalancerConfigNode",
"path": "/nodebalancers/{nodeBalancerId}/configs/{configId}/nodes/{nodeId}",
"method": "DELETE",
"description": "Deletes a node from this config. Is backend will no longer receive traffic for the configured port of this NodeBalancer. This does not change or remove the server whose address was used in the creation of this node.\n",
"name": "DeleteNodeBalancerConfigNode",
"handlerName": "HandleDeleteNodeBalancerConfigNode",
"processorName": "DeleteNodeBalancerConfigNode",
"clientName": "DeleteNodeBalancerConfigNode",
"responsesTypeName": "DeleteNodeBalancerConfigNodeResponses"
},
{
"operation": "getRegions",
"path": "/regions",
"method": "GET",
"description": "Lists the regions available for Linode services. Not all services are guaranteed to be\navailable in all regions.\n",
"name": "GetRegions",
"handlerName": "HandleGetRegions",
"processorName": "GetRegions",
"clientName": "GetRegions",
"responsesTypeName": "GetRegionsResponses"
},
{
"operation": "getRegion",
"path": "/regions/{regionId}",
"method": "GET",
"description": "Get information about a single Region.\n",
"name": "GetRegion",
"handlerName": "HandleGetRegion",
"processorName": "GetRegion",
"clientName": "GetRegion",
"responsesTypeName": "GetRegionResponses"
},
{
"operation": "getVolumes",
"path": "/volumes",
"method": "GET",
"description": "Returns a paginated list of Volumes you have permission to view.\n",
"name": "GetVolumes",
"handlerName": "HandleGetVolumes",
"processorName": "GetVolumes",
"clientName": "GetVolumes",
"responsesTypeName": "GetVolumesResponses"
},
{
"operation": "createVolume",
"path": "/volumes",
"method": "POST",
"description": "This endpoint allows you to create a new Volume on your account. In order for this to complete successfully, your user must have the `add_volumes` grant. Creating a new Volume will start accruing additional charges on your account.\nVolume service may not be available in all regions. See `GET /regions` for a list of available regions you deploy your Volume in.\n",
"name": "CreateVolume",
"handlerName": "HandleCreateVolume",
"processorName": "CreateVolume",
"clientName": "CreateVolume",
"parametersTypeName": "CreateVolumeParameters",
"responsesTypeName": "CreateVolumeResponses"
},
{
"operation": "getVolume",
"path": "/volumes/{volumeId}",
"method": "GET",
"description": "Get information about a single Volume.\n",
"name": "GetVolume",
"handlerName": "HandleGetVolume",
"processorName": "GetVolume",
"clientName": "GetVolume",
"responsesTypeName": "GetVolumeResponses"
},
{
"operation": "updateVolume",
"path": "/volumes/{volumeId}",
"method": "PUT",
"description": "This allows you to update a Volume that you have permission to `read_write`.\n",
"name": "UpdateVolume",
"handlerName": "HandleUpdateVolume",
"processorName": "UpdateVolume",
"clientName": "UpdateVolume",
"parametersTypeName": "UpdateVolumeParameters",
"responsesTypeName": "UpdateVolumeResponses"
},
{
"operation": "deleteVolume",
"path": "/volumes/{volumeId}",
"method": "DELETE",
"description": "Deletes a Volume you have permission to `read_write`. Deleting a Volume\nis a destructive process and cannot be undone. Additionally, deleting\nstops billing for the Volume. You will be billed for time used within\nthe billing period the Volume was active.\n",
"name": "DeleteVolume",
"handlerName": "HandleDeleteVolume",
"processorName": "DeleteVolume",
"clientName": "DeleteVolume",
"responsesTypeName": "DeleteVolumeResponses"
},
{
"operation": "attachVolume",
"path": "/volumes/{volumeId}/attach",
"method": "POST",
"description": "This endpoint allows you to attach a Volume on your account to an existing Linode on your account. In order for this request to complete successfully, your user must have `read_only` or `read_write` permission to the Volume and `read_write` permission to the Linode. Additionally, the Volume and Linode must be located in the same region.\n",
"name": "AttachVolume",
"handlerName": "HandleAttachVolume",
"processorName": "AttachVolume",
"clientName": "AttachVolume",
"parametersTypeName": "AttachVolumeParameters",
"responsesTypeName": "AttachVolumeResponses"
},
{
"operation": "cloneVolume",
"path": "/volumes/{volumeId}/clone",
"method": "POST",
"description": "This endpoint allows you to create a new Volume on your account. In order for this request to complete successfully, your user must have the `add_volumes` grant. The new Volume will have the same size and data as the source Volume. Creating a new Volume will incur a charge on your account.\n",
"name": "CloneVolume",
"handlerName": "HandleCloneVolume",
"processorName": "CloneVolume",
"clientName": "CloneVolume",
"parametersTypeName": "CloneVolumeParameters",
"responsesTypeName": "CloneVolumeResponses"
},
{
"operation": "detachVolume",
"path": "/volumes/{volumeId}/detach",
"method": "POST",
"description": "This endpoint allows you to detach a Volume on your account from a Linode on your account. In order for this request to complete successfully, your user must have `read_write` access to the Volume and `read_write` access to the Linode.\n",
"name": "DetachVolume",
"handlerName": "HandleDetachVolume",
"processorName": "DetachVolume",
"clientName": "DetachVolume",
"responsesTypeName": "DetachVolumeResponses"
},
{
"operation": "resizeVolume",
"path": "/volumes/{volumeId}/resize",
"method": "POST",
"description": "This endpoint allows you to resize an existing Volume on your account. In order for this request to complete successfully, your user must have the `read_write` permissions to the Volume.\n* Volumes can only be resized up.\n",
"name": "ResizeVolume",
"handlerName": "HandleResizeVolume",
"processorName": "ResizeVolume",
"clientName": "ResizeVolume",
"parametersTypeName": "ResizeVolumeParameters",
"responsesTypeName": "ResizeVolumeResponses"
},
{
"operation": "getDomainRecords",
"path": "/domains/{domainId}/records",
"method": "GET",
"description": "Returns a paginated list of records configured on a domain in Linode's\nDNS Manager.\n",
"name": "GetDomainRecords",
"handlerName": "HandleGetDomainRecords",
"processorName": "GetDomainRecords",
"clientName": "GetDomainRecords",
"responsesTypeName": "GetDomainRecordsResponses"
},
{
"path": "/domains/{domainId}/records",
"method": "POST",
"description": "Adds a new domain record to the zonefile this domain represents.\n",
"name": "POST_domains_domainId_records",
"handlerName": "HandlePOST_domains_domainId_records",
"processorName": "POST_domains_domainId_records",
"clientName": "POST_domains_domainId_records",
"parametersTypeName": "POST_domains_domainId_recordsParameters",
"responsesTypeName": "POST_domains_domainId_recordsResponses"
},
{
"path": "/domains/{domainId}/records/{recordId}",
"method": "GET",
"description": "View a single record on this domain.\n",
"name": "GET_domains_domainId_records_recordId",
"handlerName": "HandleGET_domains_domainId_records_recordId",
"processorName": "GET_domains_domainId_records_recordId",
"clientName": "GET_domains_domainId_records_recordId",
"responsesTypeName": "GET_domains_domainId_records_recordIdResponses"
},
{
"path": "/domains/{domainId}/records/{recordId}",
"method": "PUT",
"description": "Update a single record on this domain.\n",
"name": "PUT_domains_domainId_records_recordId",
"handlerName": "HandlePUT_domains_domainId_records_recordId",
"processorName": "PUT_domains_domainId_records_recordId",
"clientName": "PUT_domains_domainId_records_recordId",
"parametersTypeName": "PUT_domains_domainId_records_recordIdParameters",
"responsesTypeName": "PUT_domains_domainId_records_recordIdResponses"
},
{
"path": "/domains/{domainId}/records/{recordId}",
"method": "DELETE",
"description": "Deletes a record on this domain.\n",
"name": "DELETE_domains_domainId_records_recordId",
"handlerName": "HandleDELETE_domains_domainId_records_recordId",
"processorName": "DELETE_domains_domainId_records_recordId",
"clientName": "DELETE_domains_domainId_records_recordId",
"responsesTypeName": "DELETE_domains_domainId_records_recordIdResponses"
},
{
"operation": "getProfile",
"path": "/profile",
"method": "GET",
"description": "Returns information about the current user. This can be used to see who is acting in applications where more than one token is managed, for example in third-party OAuth applications. This endpoint is always accessible, no matter what OAuth scopes the acting token has.\n",
"name": "GetProfile",
"handlerName": "HandleGetProfile",
"processorName": "GetProfile",
"clientName": "GetProfile",
"responsesTypeName": "GetProfileResponses"
},
{
"operation": "updateProfile",
"path": "/profile",
"method": "PUT",
"description": "Update information in your profile. This option is _not_ available to all third-party clients.\n",
"name": "UpdateProfile",
"handlerName": "HandleUpdateProfile",
"processorName": "UpdateProfile",
"clientName": "UpdateProfile",
"parametersTypeName": "UpdateProfileParameters",
"responsesTypeName": "UpdateProfileResponses"
},
{
"operation": "getProfileApps",
"path": "/profile/apps",
"method": "GET",
"description": "This is a collection of OAuth apps that you've given access to your account, and includes the level of access granted.\n",
"name": "GetProfileApps",
"handlerName": "HandleGetProfileApps",
"processorName": "GetProfileApps",
"clientName": "GetProfileApps",
"responsesTypeName": "GetProfileAppsResponses"
},
{
"operation": "getProfileApp",
"path": "/profile/apps/{appId}",
"method": "GET",
"description": "Returns information about a single app you've authorized to access your account.\n",
"name": "GetProfileApp",
"handlerName": "HandleGetProfileApp",
"processorName": "GetProfileApp",
"clientName": "GetProfileApp",
"responsesTypeName": "GetProfileAppResponses"
},
{
"operation": "deleteProfileApp",
"path": "/profile/apps/{appId}",
"method": "DELETE",
"description": "Expires all tokens and refresh tokens possessed by this app. This app is no longer authorized to access your account.\n",
"name": "DeleteProfileApp",
"handlerName": "HandleDeleteProfileApp",
"processorName": "DeleteProfileApp",
"clientName": "DeleteProfileApp",
"responsesTypeName": "DeleteProfileAppResponses"
},
{
"operation": "getProfileGrants",
"path": "/profile/grants",
"method": "GET",
"description": "This returns a GrantsResponse describing what the acting user has been granted access to. For unrestricted users, this will return a 204 and no body because unrestricted users have access to everything without grants. This will not return information about entities you do not have access to. This endpoint is useful when writing third-party OAuth applications to see what options you should present to the acting user (for example, if they do not have `global.add_linodes`, you might not display a button to deploy a new Linode). Any client may access this endpoint, as no OAuth scopes are required.\n",
"name": "GetProfileGrants",
"handlerName": "HandleGetProfileGrants",
"processorName": "GetProfileGrants",
"clientName": "GetProfileGrants",
"responsesTypeName": "GetProfileGrantsResponses"
},
{
"operation": "tfaEnable",
"path": "/profile/tfa-enable",
"method": "POST",
"description": "Generates a Two Factor secret for your user.. TFA will not be enabled until you have successfully confirmed the code you were given with the `tfa-enable-confirm` endpoint (see below). Once enabled, login from untrusted computers will be required to provide a TFA code before they are successful.\n",
"name": "TfaEnable",
"handlerName": "HandleTfaEnable",
"processorName": "TfaEnable",
"clientName": "TfaEnable",
"responsesTypeName": "TfaEnableResponses"
},
{
"operation": "tfaConfirm",
"path": "/profile/tfa-enable-confirm",
"method": "POST",
"description": "Confirms that you can successfully generate Two Factor codes and enables TFA on your account. Once this is complete, login attempts from untrusted computers will be required to provide a Two Factor code before they are successful.\n",
"name": "TfaConfirm",
"handlerName": "HandleTfaConfirm",
"processorName": "TfaConfirm",
"clientName": "TfaConfirm",
"parametersTypeName": "TfaConfirmParameters",
"responsesTypeName": "TfaConfirmResponses"
},
{
"operation": "tfaDisable",
"path": "/profile/tfa-disable",
"method": "POST",
"description": "Disabled Two Factor Authentication for your user. Once successful, login attempts from untrusted computers will only require a password before being successful. This is less secure, and is discouraged.\n",
"name": "TfaDisable",
"handlerName": "HandleTfaDisable",
"processorName": "TfaDisable",
"clientName": "TfaDisable",
"responsesTypeName": "TfaDisableResponses"
},
{
"operation": "getPersonalAccessTokens",
"path": "/profile/tokens",
"method": "GET",
"description": "Returns a paginated list of Personal Access Tokens currently active for your user.\n",
"name": "GetPersonalAccessTokens",
"handlerName": "HandleGetPersonalAccessTokens",
"processorName": "GetPersonalAccessTokens",
"clientName": "GetPersonalAccessTokens",
"responsesTypeName": "GetPersonalAccessTokensResponses"
},
{
"operation": "createPersonalAccessToken",
"path": "/profile/tokens",
"method": "POST",
"description": "Creates a new Personal Access Token for your user. The raw token will be returned in the response, but will never be returned again afterward so be sure to take note of it. You may create a token with _at most_ the scopes of your current token. The created token will be able to access your account until the given expiry, or until it is revoked.\n",
"name": "CreatePersonalAccessToken",
"handlerName": "HandleCreatePersonalAccessToken",
"processorName": "CreatePersonalAccessToken",
"clientName": "CreatePersonalAccessToken",
"parametersTypeName": "CreatePersonalAccessTokenParameters",
"responsesTypeName": "CreatePersonalAccessTokenResponses"
},
{
"operation": "getPersonalAccessToken",
"path": "/profile/tokens/{tokenId}",
"method": "GET",
"description": "Returns a single Personal Access Token.\n",
"name": "GetPersonalAccessToken",
"handlerName": "HandleGetPersonalAccessToken",
"processorName": "GetPersonalAccessToken",
"clientName": "GetPersonalAccessToken",
"responsesTypeName": "GetPersonalAccessTokenResponses"
},
{
"operation": "updatePersonalAccessToken",
"path": "/profile/tokens/{tokenId}",
"method": "PUT",
"description": "Updates a Personal Access Token's label.\n",
"name": "UpdatePersonalAccessToken",
"handlerName": "HandleUpdatePersonalAccessToken",
"processorName": "UpdatePersonalAccessToken",
"clientName": "UpdatePersonalAccessToken",
"parametersTypeName": "UpdatePersonalAccessTokenParameters",
"responsesTypeName": "UpdatePersonalAccessTokenResponses"
},
{
"operation": "deletePersonalAccessToken",
"path": "/profile/tokens/{tokenId}",
"method": "DELETE",
"description": "Immediately revokes a Personal Access Token. The token will be invalidated immediately, and requests using that token will fail with a 401. It _is_ possible to revoke access to the token making the request to revoke a token, but keep in mind that doing so could lose you access to the api and require you to create a new token through some other means.\n",
"name": "DeletePersonalAccessToken",
"handlerName": "HandleDeletePersonalAccessToken",
"processorName": "DeletePersonalAccessToken",
"clientName": "DeletePersonalAccessToken",
"responsesTypeName": "DeletePersonalAccessTokenResponses"
},
{
"operation": "getTickets",
"path": "/support/tickets",
"method": "GET",
"description": "This endpoint returns a collection of Support Tickets on your account. Support Tickets can be both tickets you open with Linode for support, as well as tickets generated by Linode and regarding your account.\nThis collection includes all Support Tickets generated on your account, with open tickets returned first.\n",
"name": "GetTickets",
"handlerName": "HandleGetTickets",
"processorName": "GetTickets",
"clientName": "GetTickets",
"responsesTypeName": "GetTicketsResponses"
},
{
"operation": "createTicket",
"path": "/support/tickets",
"method": "POST",
"description": "Create a Support Ticket.\nOnly one of the ID attributes (`linode_id`, `domain_id`, etc) can be set on a single Support Ticket.\n",
"name": "CreateTicket",
"handlerName": "HandleCreateTicket",
"processorName": "CreateTicket",
"clientName": "CreateTicket",
"parametersTypeName": "CreateTicketParameters",
"responsesTypeName": "CreateTicketResponses"
},
{
"operation": "getTicket",
"path": "/support/tickets/{ticketId}",
"method": "GET",
"description": "This endpoint returns a Support Ticket under your account.\n",
"name": "GetTicket",
"handlerName": "HandleGetTicket",
"processorName": "GetTicket",
"clientName": "GetTicket",
"responsesTypeName": "GetTicketResponses"
},
{
"operation": "createTicketAttachment",
"path": "/support/tickets/{ticketId}/attachments",
"method": "POST",
"description": "This endpoint allows you to add a file attachment to an existing Support Ticket on your account. File attachments are used to assist our Support team in resolving your Support Ticket. Examples of attachments are screen shots and text files that provide additional information.\n",
"name": "CreateTicketAttachment",
"handlerName": "HandleCreateTicketAttachment",
"processorName": "CreateTicketAttachment",
"clientName": "CreateTicketAttachment",
"parametersTypeName": "CreateTicketAttachmentParameters",
"responsesTypeName": "CreateTicketAttachmentResponses"
},
{
"operation": "getTicketReplies",
"path": "/support/tickets/{ticketId}/replies",
"method": "GET",
"description": "This endpoint returns a collection of replies to a singular Support Ticket on your account.\n",
"name": "GetTicketReplies",
"handlerName": "HandleGetTicketReplies",
"processorName": "GetTicketReplies",
"clientName": "GetTicketReplies",
"responsesTypeName": "GetTicketRepliesResponses"
},
{
"operation": "createTicketReply",
"path": "/support/tickets/{ticketId}/replies",
"method": "POST",
"description": "This endpoint allows you to add a reply to an existing Support Ticket.\n",
"name": "CreateTicketReply",
"handlerName": "HandleCreateTicketReply",
"processorName": "CreateTicketReply",
"clientName": "CreateTicketReply",
"parametersTypeName": "CreateTicketReplyParameters",
"responsesTypeName": "CreateTicketReplyResponses"
}
]
}
Raw
output.txt
2018/03/27 00:20:11 unimplemented: example:<yaml:"- 1521483600000\n- 0.42\n" > type:"array" items:<schema:<type:"number" > > description:"Percentage of CPU used.\n"
2018/03/27 00:20:11 unimplemented: specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/27 00:20:11 unimplemented: read_only:true description:"This is the location where the Linode was deployed. This cannot be changed without opening a support ticket.\n" specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/27 00:20:11 unimplemented: read_only:true all_of:<reference:<_ref:"#/components/schemas/DiskRequest/properties/image" > > specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/27 00:20:11 unimplemented: read_only:true description:"This is the Linode service plan type that this Linode was deployed with.\nTo change a Linode's type, use `POST /linode/instances/{linodeId}/resize`.\n"
2018/03/27 00:20:11 unimplemented: specification_extension:<name:"x-linode-filterable" value:<yaml:"true\n" > >
2018/03/27 00:20:11 unimplemented: read_only:true type:"array" items:<schema:<example:<yaml:"654\n" > type:"integer" format:"int32" > > description:"An array of Managed Service IDs that were affected by this issue.\n"
2018/03/27 00:20:11 unimplemented: type:"array" items:<schema:<example:<yaml:"9991\n" > type:"integer" format:"int32" > > description:"An array of ManagedCredential ids that should be used when attempting to resolve issues with this service.\n"
2018/03/27 00:20:11 Syntax errors in generated code:
client.go:110:14: expected expression
client.go:140:14: expected expression
client.go:202:14: expected expression
client.go:236:14: expected expression
client.go:266:14: expected expression
client.go:324:14: expected expression
client.go:355:14: expected expression
client.go:385:14: expected expression
client.go:512:14: expected expression
client.go:573:14: expected expression
client.go:637:14: expected expression
2018/03/27 00:20:11 Syntax errors in generated code:
types.go:37:18: expected ';', found '{'
types.go:40:1: expected '}', found 'type'
types.go:137:18: expected ';', found ':'
types.go:137:51: unknown escape sequence
types.go:137:59: unknown escape sequence
types.go:137:147: unknown escape sequence
types.go:144:1: expected '}', found 'type'
types.go:314:17: expected ';', found '{'
types.go:320:1: expected '}', found 'type'
types.go:335:20: expected ';', found ':'
types.go:335:92: unknown escape sequence
types.go:336:160: unknown escape sequence
types.go:336:233: unknown escape sequence
types.go:337:187: unknown escape sequence
types.go:338:122: unknown escape sequence
types.go:338:198: unknown escape sequence
types.go:339:92: unknown escape sequence
can't load package: package .: no Go files in /Users/displague/src
Raw
provider.go
// GENERATED FILE: DO NOT EDIT!
package linode
// To create a server, first write a class that implements this interface.
// Then pass an instance of it to Initialize().
type Provider interface {
// This endpoint returns the contact and billing information related to your Account.
//
GetAccount(responses *GetAccountResponses) (err error)
// This endpoint allows you to update contact and billing information related to your Account.
//
UpdateAccount(parameters *UpdateAccountParameters, responses *UpdateAccountResponses) (err error)
// This endpoint allows you to add/edit credit card information to your Account.
// Only one credit card can be associated with your Account, so using this endpoint will overwrite your card information with the new credit card.
//
CreateCreditCard(parameters *CreateCreditCardParameters, responses *CreateCreditCardResponses) (err error)
// This endpoint returns a collection of Event objects representing actions taken on your Account. The events returned depends on your grants.
//
GetEvents(responses *GetEventsResponses) (err error)
// Returns a single Event object.
GetEvent(responses *GetEventResponses) (err error)
// Marks Event as read.
EventRead(responses *EventReadResponses) (err error)
// Marks all Events up to and including this Event by ID as seen.
//
EventSeen(responses *EventSeenResponses) (err error)
// This endpoint returns a paginated list of invoices against your Account.
//
GetInvoices(responses *GetInvoicesResponses) (err error)
// Returns a single Invoice object.
GetInvoice(responses *GetInvoiceResponses) (err error)
// Returns a paginated list of Invoice items.
GetInvoiceItems(responses *GetInvoiceItemsResponses) (err error)
// This endpoint returns a collection of Notification objects representing important, often time-sensitive items related to your account.
// You cannot interact directly with Notifications, and it will disappear when the circumstances causing the Notification have been resolved. For example, if you have an important ticket open, you must respond to the ticket to dismiss the Notification.
//
GetNotifications(responses *GetNotificationsResponses) (err error)
// Returns a paginated list of OAuth Clients registered to your account. OAuth Clients allow users to log into applications you write or host using their Linode account, and may allow them to grant some level of access to their Linodes or other entities to your application.
//
GetClients(responses *GetClientsResponses) (err error)
// Create a new OAuth Client, which can be used to allow users to login to your own applications using their Linode account, and optionally grant your application some amount of access to their Linodes or other entities.
//
CreateClient(parameters *CreateClientParameters, responses *CreateClientResponses) (err error)
// Returns information about a single OAuth client.
//
GetClient(responses *GetClientResponses) (err error)
// Update information about an OAuth Client on your account. This can be especially useful to update the redirect_uri of your client in the event that the callback url changed in your application.
//
UpdateClient(parameters *UpdateClientParameters, responses *UpdateClientResponses) (err error)
// Deletes an OAuth Client registered with Linode. The Client ID and Client Secret will no longer be accepted by https://login.linode.com, and all tokens issued to this client will be invalidated (meaning that if your application was using a token, it will no longer work).
//
DeleteClient(responses *DeleteClientResponses) (err error)
// Returns the thumbnail for this OAuth Client. This is a publicly-viewable endpoint, and can be accessed without authentication.
//
GetClientThumbnail(responses *GetClientThumbnailResponses) (err error)
// Upload a thumbnail for a client you own. You must upload an image file that will be returned when the thumbnail is retrieved. This image will be publicly-viewable.
//
SetClientThumbnail(parameters *SetClientThumbnailParameters, responses *SetClientThumbnailResponses) (err error)
// Resets the OAuth Client Secret for a client you own, and returns the OAuth Client with the plaintext secret. This secret is not supposed to be publicly known or disclosed anywhere. This can be used to generate a new secret in case the one you have has been leaked, or to get a new secret if you lost the original. The old secret is expired immediately, and logins to your client with the old secret will fail.
//
ResetClientSecret(responses *ResetClientSecretResponses) (err error)
// This endpoint returns a paginated list of Payments made on this Account.
//
GetPayments(responses *GetPaymentsResponses) (err error)
// This endpoint allows you to make a payment to your Account via credit card. This will charge your credit card the requested amount.
//
CreatePayment(parameters *CreatePaymentParameters, responses *CreatePaymentResponses) (err error)
// Returns information about a specific Payment.
//
GetPayment(responses *GetPaymentResponses) (err error)
// This begins the process of submitting a payment via PayPal. After calling
// this endpoint, you must take the resulting `payment_id` along with
// the `payer_id` from your PayPal account, and POST to
// `/account/payments/paypal-execute` to complete the payment.
//
CreatePayPalPayment(parameters *CreatePayPalPaymentParameters, responses *CreatePayPalPaymentResponses) (err error)
// Given a PaymentID and PayerID - as generated by PayPal during the transaction authorization process - this endpoint executes the payment to capture the funds and credit your Linode account.
//
ExecutePayPalPayment(parameters *ExecutePayPalPaymentParameters, responses *ExecutePayPalPaymentResponses) (err error)
// This endpoint returns information related to your Account settings: Managed service subscription, Longview subscription, and network helper.
//
GetAccountSettings(responses *GetAccountSettingsResponses) (err error)
// This endpoint allows you to update your Account settings.
//
UpdateAccountSettings(parameters *UpdateAccountSettingsParameters, responses *UpdateAccountSettingsResponses) (err error)
// Returns a paginated list of Users on your account. Users may access all or part of your account based on their restricted status and grants. An unrestricted user may access everything on the account, whereas restricted user may only access entities or perform actions they've been given specific grants to.
//
GetUsers(responses *GetUsersResponses) (err error)
// Creates a new User on your account. Once created, the user will be able to log in and access portions of your account. Access is determined by whether or not they are restricted, and what grants they have been given.
//
CreateUser(parameters *CreateUserParameters, responses *CreateUserResponses) (err error)
// Returns information about a single user on your account.
//
GetUser(responses *GetUserResponses) (err error)
// Update information about a user on your account. This can be used to change the restricted status of a user. When making a user restricted, no grants will be configured by default and you must then set up grants in order for the user to access anything on the account.
//
UpdateUser(parameters *UpdateUserParameters, responses *UpdateUserResponses) (err error)
// Deletes a user. The deleted user will be immediately logged out and may no longer log in or perform any actions. All grants that user had will be lost.
//
DeleteUser(responses *DeleteUserResponses) (err error)
// Returns the full grants structure for this user. This includes all entities on the account alongside what level of access this user has to each of them. Individual users may view their own grants at the `/profile/grants` endpoint, but will not see entities that they have no access to.
//
GetUserGrants(responses *GetUserGrantsResponses) (err error)
// Update the grants a user has. This can be used to give a user access to new entities or actions, or take access away. You do not need to include the grant for every entity on the account in this request; any that are not included will remain unchanged.
//
UpdateUserGrants(parameters *UpdateUserGrantsParameters, responses *UpdateUserGrantsResponses) (err error)
// This endpoint returns a Transfer object.
//
GetTransfer(responses *GetTransferResponses) (err error)
// This is a collection of domains that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for these to work you must own the domains and point your registrar at Linode's nameservers.
//
GetDomains(responses *GetDomainsResponses) (err error)
// Adds a new domain to Linode's DNS Manager. Linode is not a registrar, and you must own the domain before adding it here. Be sure to point your registrar to Linode's nameservers so that the records hosted here are used.
//
CreateDomain(parameters *CreateDomainParameters, responses *CreateDomainResponses) (err error)
// This is a single domain that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for this domain record to work you must own the domain and point your registrar at Linode's nameservers.
//
GetDomain(responses *GetDomainResponses) (err error)
// Update information about a domain in Linode's DNS Manager.
//
UpdateDomain(parameters *UpdateDomainParameters, responses *UpdateDomainResponses) (err error)
// Deletes a domain from Linode's DNS Manager. The domain will be removed from Linode's nameservers shortly after this operation completes. This also deletes all associated Domain Records.
//
DeleteDomain(responses *DeleteDomainResponses) (err error)
// Returns a paginated list of Images. This list includes public Images and your private Images. You can call this enpoint without authentication to get all of the public Images.
//
GetImages(responses *GetImagesResponses) (err error)
// Creates a new private gold-master Image from a Linode Disk. There is no additional charge to store Images for Linode users, with a limit of 2GB per Image and 3 Images per account.
//
CreateImage(parameters *CreateImageParameters, responses *CreateImageResponses) (err error)
// Get information about a single image.
//
GetImage(responses *GetImageResponses) (err error)
// This allows you to update an private Image that you have permission to `read_write`.
//
UpdateImage(parameters *UpdateImageParameters, responses *UpdateImageResponses) (err error)
// Deletes an Image you have permission to `read_write`. Deleting an image is a destructive
// process and cannot be undone. Only private Images are deletable.
//
DeleteImage(responses *DeleteImageResponses) (err error)
// Returns a paginated list of Linodes you have permission to view.
//
GetLinodeInstaces(responses *GetLinodeInstacesResponses) (err error)
// This endpoint allows you to create a new Linode server 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. See `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, see `GET /regions` for a list
// of available regions you deploy your Linode in.
//
// Linodes can be created in a number of ways:
//
// - Using a Linode Linux Distribution image or an image you created based on another Linode
// - The Linode will be `running` after it completes `provisioning`
// - A default a 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 `password` 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
//
// - Using one of your own StackScripts or a public StackScript
// - The Linode will be `running` after it completes `provisioning`
// - Requires a compatible Linode Linux Distribution `image` to be supplied
// - see `GET /linode/stackscript/{stackscriptId}` 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
//
// - Using one of your other Linode's backups
// - The Linode will be `running` after it completes `provisioning`
// - 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
//
// - Create an empty Linode
// - The Linode will remain `offline` and must be manually started
// - see `POST /linode/instances/{linodeId}/boot`
// - Disks and Configs must be created manually
// - This is only recommended for advanced use-cases
//
CreateLinodeInstance(parameters *CreateLinodeInstanceParameters, responses *CreateLinodeInstanceResponses) (err error)
// Get a specific Linode by ID.
GetLinodeInstance(responses *GetLinodeInstanceResponses) (err error)
// This allows you to update a Linode that you have permission to `read_write`.
//
UpdateLinodeInstance(parameters *UpdateLinodeInstanceParameters, responses *UpdateLinodeInstanceResponses) (err error)
// Deletes a Linode you have permission to `read_write`. Deleting a Linode is a destructive
// process and cannot be undone. Additionally, deleting a Linode:
//
// * Gives up any IP addresses the Linode was assigned
// * Deletes all disks, backups, configs, etc.
// * Stops billing for the Linode and its associated services. You will be billed for time used
// within the billing period the Linode was active.
//
DeleteLinodeInstance(responses *DeleteLinodeInstanceResponses) (err error)
// Returns information about this Linode's available backups.
//
GetBackups(responses *GetBackupsResponses) (err error)
// Creates a snapshot backup of a Linode. WARNING: If you already have a snapshot this is a destructive operation. The previous snapshot will be deleted.
//
CreateSnapshot(parameters *CreateSnapshotParameters, responses *CreateSnapshotResponses) (err error)
// Cancels the backup service on the given Linode.
//
CancelBackups(responses *CancelBackupsResponses) (err error)
// Enables backups for the specified Linode.
//
EnableBackups(responses *EnableBackupsResponses) (err error)
// Return information about a backup.
//
GetBackup(responses *GetBackupResponses) (err error)
// Restores a Linode's backup to the specified Linode.
//
RestoreBackup(parameters *RestoreBackupParameters, responses *RestoreBackupResponses) (err error)
// 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.
//
BootLinodeInstance(parameters *BootLinodeInstanceParameters, responses *BootLinodeInstanceResponses) (err error)
// 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.
//
RebootLinodeInstance(responses *RebootLinodeInstanceResponses) (err error)
// 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.
//
ShutdownLinodeInstance(responses *ShutdownLinodeInstanceResponses) (err error)
// 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.
//
MutateLinodeInstance(responses *MutateLinodeInstanceResponses) (err error)
// 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:
//
// * Any pending free upgrades to the Linode's current type must be performed
// before a resize can occur.
// * 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.
//
ResizeLinodeInstance(parameters *ResizeLinodeInstanceParameters, responses *ResizeLinodeInstanceResponses) (err error)
// This endpoint allows you to rebuild a Linode if you have the `read_write` permission for it. If any actions are currently running or queued, those actions must be completed first before you can initiate a rebuild.
// 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.
//
RebuildLinodeInstance(parameters *RebuildLinodeInstanceParameters, responses *RebuildLinodeInstanceResponses) (err error)
// 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.
//
RescueLinodeInstance(parameters *RescueLinodeInstanceParameters, responses *RescueLinodeInstanceResponses) (err error)
// 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.
//
CloneLinodeInstance(parameters *CloneLinodeInstanceParameters, responses *CloneLinodeInstanceResponses) (err error)
// Returns networking information for a single Linode.
//
GetLinodeIPs(responses *GetLinodeIPsResponses) (err error)
// Allocate a public or private IPv4 address to a Linode. Public IP Addresses, over and above 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 ticket. One may not add more than one private IPv4 address to a single Linode.
//
AddLinodeIP(responses *AddLinodeIPResponses) (err error)
// View information about the specified IP address associated with the specified Linode.
//
GetLinodeIP(responses *GetLinodeIPResponses) (err error)
// Manage a particular IP Address associated with this Linode. Currently only allows setting/resetting reverse DNS.
//
UpdateLinodeIP(parameters *UpdateLinodeIPParameters, responses *UpdateLinodeIPResponses) (err error)
// Delete a public IPv4 address associated with this Linode. This will fail if it is the Linode's last remaining IP address. Private IPv4 addresses cannot be removed via this endpoint.
//
RemoveLinodeIP(responses *RemoveLinodeIPResponses) (err error)
// View Block Storage Volumes attached to this Linode.
//
GetLinodeVolumes(responses *GetLinodeVolumesResponses) (err error)
// Lists configuration profiles associated with a Linode.
//
GetLinodeConfigs(responses *GetLinodeConfigsResponses) (err error)
// Adds a new configuration profile to a Linode.
//
AddLinodeConfig(parameters *AddLinodeConfigParameters, responses *AddLinodeConfigResponses) (err error)
// Returns information about a specific configuration profile.
//
GetLinodeConfig(responses *GetLinodeConfigResponses) (err error)
// Updates the parameters of a single configuration profile.
//
UpdateLinodeConfig(parameters *UpdateLinodeConfigParameters, responses *UpdateLinodeConfigResponses) (err error)
// Deletes the specified configuration profile from the specified Linode.
//
DELETE_linode_instances_linodeId_configs_configId(responses *DELETE_linode_instances_linodeId_configs_configIdResponses) (err error)
// View Disk information for disks associated with this Linode.
//
GetLinodeDisks(responses *GetLinodeDisksResponses) (err error)
// Adds a new disk to a Linode. You can optionally create a disk from an image (see `GET /images` for a list of available public images, or use one of your own), and optionally provide a StackScript to deploy with this Disk.
//
AddLinodeDisk(parameters *AddLinodeDiskParameters, responses *AddLinodeDiskResponses) (err error)
// View Disk information for a disk associated with this Linode.
//
GetLinodeDisk(responses *GetLinodeDiskResponses) (err error)
// This allows you to update a Disk that you have permission to `read_write`.
//
UpdateDisk(parameters *UpdateDiskParameters, responses *UpdateDiskResponses) (err error)
// Deletes a Disk you have permission to `read_write`. Deleting a Disk is a
// destructive process and cannot be undone.
//
DeleteDisk(responses *DeleteDiskResponses) (err error)
// This endpoint allows you to reset the password of a disk you have permission to `read_write`.
//
ResetDiskPassword(parameters *ResetDiskPasswordParameters, responses *ResetDiskPasswordResponses) (err error)
// This endpoint allows you to resize a disk you have permission to `read_write`.
// The Linode this Disk is attached to must be shut down for resizing to take effect.
// 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.
//
ResizeDisk(parameters *ResizeDiskParameters, responses *ResizeDiskResponses) (err error)
// This endpoint returns CPU, IO, IPv4, and IPv6 statistics for your Linode for the past 24 hours.
//
GetLinodeStats(responses *GetLinodeStatsResponses) (err error)
// This endpoint 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.
//
GetLinodeStatsByYearMonth(responses *GetLinodeStatsByYearMonthResponses) (err error)
// Lists available kernels.
//
GetKernels(responses *GetKernelsResponses) (err error)
// Get information about a single kernel.
//
GetKernel(responses *GetKernelResponses) (err error)
// Returns a list of publicly available StackScripts. If the request is authenticated, the list also includes private StackScripts the user has permissions to view.
//
GetStackScripts(responses *GetStackScriptsResponses) (err error)
// This endpoint allows you to add a new StackScript to your account.
//
AddStackScript(parameters *AddStackScriptParameters, responses *AddStackScriptResponses) (err error)
// This endpoint returns all of the information about a specified StackScript, including the contents of the script.
//
GetStackScript(responses *GetStackScriptResponses) (err error)
// This endpoint allows you to modify a StackScript. Setting a StackScript to public is a permanent change.
//
UpdateStackScript(responses *UpdateStackScriptResponses) (err error)
// This endpoint allows you to permanently delete a specific StackScript. You cannot delete a public StackScript.
//
DeleteStackScript(responses *DeleteStackScriptResponses) (err error)
// Returns collection of Linode types, including pricing and specifications for each type. These are used when creating or resizing Linodes.
//
GetLinodeTypes(responses *GetLinodeTypesResponses) (err error)
// Returns information about a specific Linode type, including pricing and specifications. This is used when creating or resizing a Linode.
//
GetLinodeType(responses *GetLinodeTypeResponses) (err error)
// Returns a paginated list of Managed Contacts on your account.
//
GetManagedContacts(responses *GetManagedContactsResponses) (err error)
// Creates a new Managed Contact. A Managed Contact is someone Linode special forces can contact in the course of attempting to resolve an issue with a Managed Service.
//
CreateManagedContact(parameters *CreateManagedContactParameters, responses *CreateManagedContactResponses) (err error)
// Returns a single Managed Contact.
//
GetManagedContact(responses *GetManagedContactResponses) (err error)
// Updates information about a Managed Contact.
//
UpdateManagedContact(parameters *UpdateManagedContactParameters, responses *UpdateManagedContactResponses) (err error)
// Deletes a Managed Contact.
//
DeleteManagedContact(responses *DeleteManagedContactResponses) (err error)
// Returns a paginated list of Managed Credentials on your account.
//
GetManagedCredentials(responses *GetManagedCredentialsResponses) (err error)
// Creates a new Managed Credential. A Managed Credential is stored securely to allow Linode special forces to access your Managed Services and resolve issues.
//
CreateManagedCredential(parameters *CreateManagedCredentialParameters, responses *CreateManagedCredentialResponses) (err error)
// Returns a single Managed Credential.
//
GetManagedCredential(responses *GetManagedCredentialResponses) (err error)
// Updates information about a Managed Credential.
//
UpdateManagedCredential(parameters *UpdateManagedCredentialParameters, responses *UpdateManagedCredentialResponses) (err error)
// Deletes a Managed Credential. Linode special forces will no longer have access to this credential when attempting to resolve issues.
//
DeleteManagedCredential(responses *DeleteManagedCredentialResponses) (err error)
// Returns a paginated list of recent and ongoing issues detected on your Managed Services.
//
GetManagedIssues(responses *GetManagedIssuesResponses) (err error)
// Returns a single issue that is impacting or did impact one of your Managed Services.
//
GetManagedIssue(responses *GetManagedIssueResponses) (err error)
// Returns a paginated list of Managed settings for your Linodes. There will be one entry per Linode on your account.
//
GetManagedLinodeSettings(responses *GetManagedLinodeSettingsResponses) (err error)
// Returns a single Linode's Managed settings.
//
GetManagedLinodeSetting(responses *GetManagedLinodeSettingResponses) (err error)
// Updates a single Linode's Managed settings.
//
UpdateManagedLinodeSetting(parameters *UpdateManagedLinodeSettingParameters, responses *UpdateManagedLinodeSettingResponses) (err error)
// Returns a paginated list of Managed Services on your account. These are the services Linode Managed is monitoring and will report and attempt to resolve issues with.
//
GetManagedServices(responses *GetManagedServicesResponses) (err error)
// Creates a new Managed Service. Linode Managed will being monitoring this service and reporting and attempting to resolve any issues.
//
CreateManagedService(parameters *CreateManagedServiceParameters, responses *CreateManagedServiceResponses) (err error)
// Returns information about a single Managed Service on your account.
//
GetManagedService(responses *GetManagedServiceResponses) (err error)
// Updates information about a Managed Service.
//
UpdateManagedService(parameters *UpdateManagedServiceParameters, responses *UpdateManagedServiceResponses) (err error)
// Deletes a Managed Service. This service will no longer be monitored by Linode Managed.
//
DeleteManagedService(responses *DeleteManagedServiceResponses) (err error)
// Temporarily disables monitoring of a Managed Service.
//
DisableManagedService(responses *DisableManagedServiceResponses) (err error)
// Re-enables monitoring of a Managed Service.
//
EnableManagedService(responses *EnableManagedServiceResponses) (err error)
// Returns a paginated list of IP Addresses on your account, excluding private addresses.
//
GetIPs(responses *GetIPsResponses) (err error)
// Allocates a new IP Address on your account. Currently, only IPv4 addresses may be allocated this way. The Linode you are allocating this address for must be allowed to allocate additional addresses - please open a support ticket requesting additional addresses before attempting allocation.
//
AllocateIP(parameters *AllocateIPParameters, responses *AllocateIPResponses) (err error)
// Returns information about a single IP Address on your account.
//
GetIP(responses *GetIPResponses) (err error)
// Sets RDNS on an IP Address. Forward DNS must already be set up for reverse DNS to be applied. If you set the RDNS to `null` for public ipv4 addresses, it will be reset to the default members.linode.com RDNS value.
//
UpdateIP(parameters *UpdateIPParameters, responses *UpdateIPResponses) (err error)
// Returns a paginated list of Longview Clients you have access to. Longview Clients are used to monitor stats on your servers with the help of the Longview Client application.
//
GetLongviewClients(responses *GetLongviewClientsResponses) (err error)
// Create a new Longview Client. This client will not begin monitoring the status of one of your servers until you configure the Longview Client application on your server using the returning `install_code` and `api_key`.
//
CreateLongviewClient(parameters *CreateLongviewClientParameters, responses *CreateLongviewClientResponses) (err error)
// Returns a single Longview Client you can access.
//
GetLongviewClient(responses *GetLongviewClientResponses) (err error)
// Updates a Longview Client. This cannot update how it monitors your server - use the Longview Client application on your server for monitoring configuration.
//
UpdateLongviewClient(parameters *UpdateLongviewClientParameters, responses *UpdateLongviewClientResponses) (err error)
// Deletes a Longview Client from your account. All information stored for this client will be lost. This _does not_ uninstall the Longview Client application for your server - you must do that manually.
//
DeleteLongviewClient(responses *DeleteLongviewClientResponses) (err error)
// Returns a paginated list of available Longview Subscriptions. This is a public endpoint, and requires no authentication.
//
GetLongviewSubscriptions(responses *GetLongviewSubscriptionsResponses) (err error)
// Returns a single LongviewSubscription object. This is a public endpoint and requires no authentication.
//
GetLongviewSubscription(responses *GetLongviewSubscriptionResponses) (err error)
// Assign multiple IPs to multiple Linodes in one region. This allows swapping, shuffling, or otherwise reorganizing v4 IP Addresses to your Linodes. When the assignment is finished, all Linodes must end up with at least one public ipv4 and no more than one private ipv4.
//
AssignIPs(parameters *AssignIPsParameters, responses *AssignIPsResponses) (err error)
// Configure shared IPs. A shared IP may be brought up on a Linode other than the one it lists in its response. This can be used to allow one Linode to begin serving requests should another become unresponsive.
//
ShareIPs(parameters *ShareIPsParameters, responses *ShareIPsResponses) (err error)
// Displays the IPv6 pools on your account.
//
GetIPv6Pools(responses *GetIPv6PoolsResponses) (err error)
// Displays the IPv6 ranges on your account.
//
GetIPv6Ranges(responses *GetIPv6RangesResponses) (err error)
// Returns a paginated list of NodeBalancers you have access to.
//
GetNodeBalancers(responses *GetNodeBalancersResponses) (err error)
// Creates a new NodeBalancer in the requested region. This NodeBalancer will not start serving requests until it is configured.
//
CreateNodeBalancer(parameters *CreateNodeBalancerParameters, responses *CreateNodeBalancerResponses) (err error)
// Returns a single NodeBalancer you can access.
//
GetNodeBalancer(responses *GetNodeBalancerResponses) (err error)
// Update information about a NodeBalancer you can access.
//
UpdateNodeBalancer(parameters *UpdateNodeBalancerParameters, responses *UpdateNodeBalancerResponses) (err error)
// Deletes a NodeBalancer. This cannot be undone. Deleting a NodeBalancer will also delete all associated configs and nodes, although the backend servers represented by the nodes will not be changed or removed. Deleting a NodeBalancer will cause you to lose access to the IP Addresses that NodeBalancer was assigned.
//
DeleteNodeBalancer(responses *DeleteNodeBalancerResponses) (err error)
// Returns a paginated list of NodeBalancerConfigs associated with this NodeBalancer. NodeBalancer configs represent individual ports that this NodeBalancer will accept traffic on, one config per port. For example, if you wanted to accept standard http traffic, you would need a config listening on port 80.
//
GetNodeBalancerConfigs(responses *GetNodeBalancerConfigsResponses) (err error)
// Creates a new NodeBalancerConfig, which allows the NodeBalancer to accept traffic on a new port. You will need to add NodeBalancerNodes to the new config before it can actually serve requests.
//
CreateaNodeBalancerConfig(parameters *CreateaNodeBalancerConfigParameters, responses *CreateaNodeBalancerConfigResponses) (err error)
// Returns configuration information for a single port of this NodeBalancer.
//
GetNodeBalancerConfig(responses *GetNodeBalancerConfigResponses) (err error)
// Update the configuration for a single port on a NodeBalancer.
//
UpdateNodeBalancerConfig(parameters *UpdateNodeBalancerConfigParameters, responses *UpdateNodeBalancerConfigResponses) (err error)
// Deletes the configuration for a port of this NodeBalancer. This cannot be undone. Once completed, this NodeBalancer will no longer respond to requests on the given port. This also deletes all associated NodeBalancerNodes, but the Linodes they were routing traffic to are unchanged and not removed.
//
DeleteNodeBalancerConfig(responses *DeleteNodeBalancerConfigResponses) (err error)
// Returns a paginated list of NodeBalancer nodes associated with this config. These are the backends that will be sent traffic for this port.
//
GetNodeBalancerConfigNodes(responses *GetNodeBalancerConfigNodesResponses) (err error)
// Creates a new NodeBalancer node, a backend that can accept traffic, for this NodeBalancer config. Nodes are routed requests on the configured port based on their status.
//
CreateNodeBalancerNode(parameters *CreateNodeBalancerNodeParameters, responses *CreateNodeBalancerNodeResponses) (err error)
// Returns information about a single node, a backend for this NodeBalancer's configured port.
//
GetNodeBalancerNode(responses *GetNodeBalancerNodeResponses) (err error)
// Updates information about a node, a backend for this NodeBalancer's configured port.
//
UpdateNodeBalancerNode(parameters *UpdateNodeBalancerNodeParameters, responses *UpdateNodeBalancerNodeResponses) (err error)
// Deletes a node from this config. Is backend will no longer receive traffic for the configured port of this NodeBalancer. This does not change or remove the server whose address was used in the creation of this node.
//
DeleteNodeBalancerConfigNode(responses *DeleteNodeBalancerConfigNodeResponses) (err error)
// Lists the regions available for Linode services. Not all services are guaranteed to be
// available in all regions.
//
GetRegions(responses *GetRegionsResponses) (err error)
// Get information about a single Region.
//
GetRegion(responses *GetRegionResponses) (err error)
// Returns a paginated list of Volumes you have permission to view.
//
GetVolumes(responses *GetVolumesResponses) (err error)
// This endpoint allows you to create a new Volume on your account. In order for this to complete successfully, your user must have the `add_volumes` grant. Creating a new Volume will start accruing additional charges on your account.
// Volume service may not be available in all regions. See `GET /regions` for a list of available regions you deploy your Volume in.
//
CreateVolume(parameters *CreateVolumeParameters, responses *CreateVolumeResponses) (err error)
// Get information about a single Volume.
//
GetVolume(responses *GetVolumeResponses) (err error)
// This allows you to update a Volume that you have permission to `read_write`.
//
UpdateVolume(parameters *UpdateVolumeParameters, responses *UpdateVolumeResponses) (err error)
// Deletes a Volume you have permission to `read_write`. Deleting a Volume
// is a destructive process and cannot be undone. Additionally, deleting
// stops billing for the Volume. You will be billed for time used within
// the billing period the Volume was active.
//
DeleteVolume(responses *DeleteVolumeResponses) (err error)
// This endpoint allows you to attach a Volume on your account to an existing Linode on your account. In order for this request to complete successfully, your user must have `read_only` or `read_write` permission to the Volume and `read_write` permission to the Linode. Additionally, the Volume and Linode must be located in the same region.
//
AttachVolume(parameters *AttachVolumeParameters, responses *AttachVolumeResponses) (err error)
// This endpoint allows you to create a new Volume on your account. In order for this request to complete successfully, your user must have the `add_volumes` grant. The new Volume will have the same size and data as the source Volume. Creating a new Volume will incur a charge on your account.
//
CloneVolume(parameters *CloneVolumeParameters, responses *CloneVolumeResponses) (err error)
// This endpoint allows you to detach a Volume on your account from a Linode on your account. In order for this request to complete successfully, your user must have `read_write` access to the Volume and `read_write` access to the Linode.
//
DetachVolume(responses *DetachVolumeResponses) (err error)
// This endpoint allows you to resize an existing Volume on your account. In order for this request to complete successfully, your user must have the `read_write` permissions to the Volume.
// * Volumes can only be resized up.
//
ResizeVolume(parameters *ResizeVolumeParameters, responses *ResizeVolumeResponses) (err error)
// Returns a paginated list of records configured on a domain in Linode's
// DNS Manager.
//
GetDomainRecords(responses *GetDomainRecordsResponses) (err error)
// Adds a new domain record to the zonefile this domain represents.
//
POST_domains_domainId_records(parameters *POST_domains_domainId_recordsParameters, responses *POST_domains_domainId_recordsResponses) (err error)
// View a single record on this domain.
//
GET_domains_domainId_records_recordId(responses *GET_domains_domainId_records_recordIdResponses) (err error)
// Update a single record on this domain.
//
PUT_domains_domainId_records_recordId(parameters *PUT_domains_domainId_records_recordIdParameters, responses *PUT_domains_domainId_records_recordIdResponses) (err error)
// Deletes a record on this domain.
//
DELETE_domains_domainId_records_recordId(responses *DELETE_domains_domainId_records_recordIdResponses) (err error)
// Returns information about the current user. This can be used to see who is acting in applications where more than one token is managed, for example in third-party OAuth applications. This endpoint is always accessible, no matter what OAuth scopes the acting token has.
//
GetProfile(responses *GetProfileResponses) (err error)
// Update information in your profile. This option is _not_ available to all third-party clients.
//
UpdateProfile(parameters *UpdateProfileParameters, responses *UpdateProfileResponses) (err error)
// This is a collection of OAuth apps that you've given access to your account, and includes the level of access granted.
//
GetProfileApps(responses *GetProfileAppsResponses) (err error)
// Returns information about a single app you've authorized to access your account.
//
GetProfileApp(responses *GetProfileAppResponses) (err error)
// Expires all tokens and refresh tokens possessed by this app. This app is no longer authorized to access your account.
//
DeleteProfileApp(responses *DeleteProfileAppResponses) (err error)
// This returns a GrantsResponse describing what the acting user has been granted access to. For unrestricted users, this will return a 204 and no body because unrestricted users have access to everything without grants. This will not return information about entities you do not have access to. This endpoint is useful when writing third-party OAuth applications to see what options you should present to the acting user (for example, if they do not have `global.add_linodes`, you might not display a button to deploy a new Linode). Any client may access this endpoint, as no OAuth scopes are required.
//
GetProfileGrants(responses *GetProfileGrantsResponses) (err error)
// Generates a Two Factor secret for your user.. TFA will not be enabled until you have successfully confirmed the code you were given with the `tfa-enable-confirm` endpoint (see below). Once enabled, login from untrusted computers will be required to provide a TFA code before they are successful.
//
TfaEnable(responses *TfaEnableResponses) (err error)
// Confirms that you can successfully generate Two Factor codes and enables TFA on your account. Once this is complete, login attempts from untrusted computers will be required to provide a Two Factor code before they are successful.
//
TfaConfirm(parameters *TfaConfirmParameters, responses *TfaConfirmResponses) (err error)
// Disabled Two Factor Authentication for your user. Once successful, login attempts from untrusted computers will only require a password before being successful. This is less secure, and is discouraged.
//
TfaDisable(responses *TfaDisableResponses) (err error)
// Returns a paginated list of Personal Access Tokens currently active for your user.
//
GetPersonalAccessTokens(responses *GetPersonalAccessTokensResponses) (err error)
// Creates a new Personal Access Token for your user. The raw token will be returned in the response, but will never be returned again afterward so be sure to take note of it. You may create a token with _at most_ the scopes of your current token. The created token will be able to access your account until the given expiry, or until it is revoked.
//
CreatePersonalAccessToken(parameters *CreatePersonalAccessTokenParameters, responses *CreatePersonalAccessTokenResponses) (err error)
// Returns a single Personal Access Token.
//
GetPersonalAccessToken(responses *GetPersonalAccessTokenResponses) (err error)
// Updates a Personal Access Token's label.
//
UpdatePersonalAccessToken(parameters *UpdatePersonalAccessTokenParameters, responses *UpdatePersonalAccessTokenResponses) (err error)
// Immediately revokes a Personal Access Token. The token will be invalidated immediately, and requests using that token will fail with a 401. It _is_ possible to revoke access to the token making the request to revoke a token, but keep in mind that doing so could lose you access to the api and require you to create a new token through some other means.
//
DeletePersonalAccessToken(responses *DeletePersonalAccessTokenResponses) (err error)
// This endpoint returns a collection of Support Tickets on your account. Support Tickets can be both tickets you open with Linode for support, as well as tickets generated by Linode and regarding your account.
// This collection includes all Support Tickets generated on your account, with open tickets returned first.
//
GetTickets(responses *GetTicketsResponses) (err error)
// Create a Support Ticket.
// Only one of the ID attributes (`linode_id`, `domain_id`, etc) can be set on a single Support Ticket.
//
CreateTicket(parameters *CreateTicketParameters, responses *CreateTicketResponses) (err error)
// This endpoint returns a Support Ticket under your account.
//
GetTicket(responses *GetTicketResponses) (err error)
// This endpoint allows you to add a file attachment to an existing Support Ticket on your account. File attachments are used to assist our Support team in resolving your Support Ticket. Examples of attachments are screen shots and text files that provide additional information.
//
CreateTicketAttachment(parameters *CreateTicketAttachmentParameters, responses *CreateTicketAttachmentResponses) (err error)
// This endpoint returns a collection of replies to a singular Support Ticket on your account.
//
GetTicketReplies(responses *GetTicketRepliesResponses) (err error)
// This endpoint allows you to add a reply to an existing Support Ticket.
//
CreateTicketReply(parameters *CreateTicketReplyParameters, responses *CreateTicketReplyResponses) (err error)
}
Raw
server.go
This file has been truncated, but you can view the full file.
// GENERATED FILE: DO NOT EDIT!
package linode
import (
"encoding/json"
"errors"
"net/http"
"strconv"
"github.com/gorilla/mux"
)
func intValue(s string) (v int64) {
v, _ = strconv.ParseInt(s, 10, 64)
return v
}
// This package-global variable holds the user-written Provider for API services.
// See the Provider interface for details.
var provider Provider
// These handlers serve API methods.
// Handler
// This endpoint returns the contact and billing information related to your Account.
//
func HandleGetAccount(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetAccountResponses{}
// call the service provider
err = provider.GetAccount(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint allows you to update contact and billing information related to your Account.
//
func HandleUpdateAccount(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateAccountParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateAccountResponses{}
// call the service provider
err = provider.UpdateAccount(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint allows you to add/edit credit card information to your Account.
// Only one credit card can be associated with your Account, so using this endpoint will overwrite your card information with the new credit card.
//
func HandleCreateCreditCard(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreateCreditCardParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Creditcard)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreateCreditCardResponses{}
// call the service provider
err = provider.CreateCreditCard(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint returns a collection of Event objects representing actions taken on your Account. The events returned depends on your grants.
//
func HandleGetEvents(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetEventsResponses{}
// call the service provider
err = provider.GetEvents(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns a single Event object.
func HandleGetEvent(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetEventResponses{}
// call the service provider
err = provider.GetEvent(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Marks Event as read.
func HandleEventRead(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &EventReadResponses{}
// call the service provider
err = provider.EventRead(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Marks all Events up to and including this Event by ID as seen.
//
func HandleEventSeen(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &EventSeenResponses{}
// call the service provider
err = provider.EventSeen(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint returns a paginated list of invoices against your Account.
//
func HandleGetInvoices(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetInvoicesResponses{}
// call the service provider
err = provider.GetInvoices(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns a single Invoice object.
func HandleGetInvoice(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetInvoiceResponses{}
// call the service provider
err = provider.GetInvoice(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns a paginated list of Invoice items.
func HandleGetInvoiceItems(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetInvoiceItemsResponses{}
// call the service provider
err = provider.GetInvoiceItems(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint returns a collection of Notification objects representing important, often time-sensitive items related to your account.
// You cannot interact directly with Notifications, and it will disappear when the circumstances causing the Notification have been resolved. For example, if you have an important ticket open, you must respond to the ticket to dismiss the Notification.
//
func HandleGetNotifications(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetNotificationsResponses{}
// call the service provider
err = provider.GetNotifications(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns a paginated list of OAuth Clients registered to your account. OAuth Clients allow users to log into applications you write or host using their Linode account, and may allow them to grant some level of access to their Linodes or other entities to your application.
//
func HandleGetClients(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetClientsResponses{}
// call the service provider
err = provider.GetClients(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Create a new OAuth Client, which can be used to allow users to login to your own applications using their Linode account, and optionally grant your application some amount of access to their Linodes or other entities.
//
func HandleCreateClient(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreateClientParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Object)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreateClientResponses{}
// call the service provider
err = provider.CreateClient(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns information about a single OAuth client.
//
func HandleGetClient(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetClientResponses{}
// call the service provider
err = provider.GetClient(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Update information about an OAuth Client on your account. This can be especially useful to update the redirect_uri of your client in the event that the callback url changed in your application.
//
func HandleUpdateClient(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateClientParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateClientResponses{}
// call the service provider
err = provider.UpdateClient(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Deletes an OAuth Client registered with Linode. The Client ID and Client Secret will no longer be accepted by https://login.linode.com, and all tokens issued to this client will be invalidated (meaning that if your application was using a token, it will no longer work).
//
func HandleDeleteClient(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &DeleteClientResponses{}
// call the service provider
err = provider.DeleteClient(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns the thumbnail for this OAuth Client. This is a publicly-viewable endpoint, and can be accessed without authentication.
//
func HandleGetClientThumbnail(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetClientThumbnailResponses{}
// call the service provider
err = provider.GetClientThumbnail(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Upload a thumbnail for a client you own. You must upload an image file that will be returned when the thumbnail is retrieved. This image will be publicly-viewable.
//
func HandleSetClientThumbnail(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &SetClientThumbnailParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &SetClientThumbnailResponses{}
// call the service provider
err = provider.SetClientThumbnail(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Resets the OAuth Client Secret for a client you own, and returns the OAuth Client with the plaintext secret. This secret is not supposed to be publicly known or disclosed anywhere. This can be used to generate a new secret in case the one you have has been leaked, or to get a new secret if you lost the original. The old secret is expired immediately, and logins to your client with the old secret will fail.
//
func HandleResetClientSecret(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &ResetClientSecretResponses{}
// call the service provider
err = provider.ResetClientSecret(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint returns a paginated list of Payments made on this Account.
//
func HandleGetPayments(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetPaymentsResponses{}
// call the service provider
err = provider.GetPayments(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint allows you to make a payment to your Account via credit card. This will charge your credit card the requested amount.
//
func HandleCreatePayment(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreatePaymentParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Paymentrequest)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreatePaymentResponses{}
// call the service provider
err = provider.CreatePayment(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns information about a specific Payment.
//
func HandleGetPayment(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetPaymentResponses{}
// call the service provider
err = provider.GetPayment(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This begins the process of submitting a payment via PayPal. After calling
// this endpoint, you must take the resulting `payment_id` along with
// the `payer_id` from your PayPal account, and POST to
// `/account/payments/paypal-execute` to complete the payment.
//
func HandleCreatePayPalPayment(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreatePayPalPaymentParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Paypal)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreatePayPalPaymentResponses{}
// call the service provider
err = provider.CreatePayPalPayment(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Given a PaymentID and PayerID - as generated by PayPal during the transaction authorization process - this endpoint executes the payment to capture the funds and credit your Linode account.
//
func HandleExecutePayPalPayment(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &ExecutePayPalPaymentParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Paypalexecute)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &ExecutePayPalPaymentResponses{}
// call the service provider
err = provider.ExecutePayPalPayment(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint returns information related to your Account settings: Managed service subscription, Longview subscription, and network helper.
//
func HandleGetAccountSettings(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetAccountSettingsResponses{}
// call the service provider
err = provider.GetAccountSettings(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint allows you to update your Account settings.
//
func HandleUpdateAccountSettings(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateAccountSettingsParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateAccountSettingsResponses{}
// call the service provider
err = provider.UpdateAccountSettings(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns a paginated list of Users on your account. Users may access all or part of your account based on their restricted status and grants. An unrestricted user may access everything on the account, whereas restricted user may only access entities or perform actions they've been given specific grants to.
//
func HandleGetUsers(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetUsersResponses{}
// call the service provider
err = provider.GetUsers(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Creates a new User on your account. Once created, the user will be able to log in and access portions of your account. Access is determined by whether or not they are restricted, and what grants they have been given.
//
func HandleCreateUser(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreateUserParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Object)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreateUserResponses{}
// call the service provider
err = provider.CreateUser(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns information about a single user on your account.
//
func HandleGetUser(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetUserResponses{}
// call the service provider
err = provider.GetUser(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Update information about a user on your account. This can be used to change the restricted status of a user. When making a user restricted, no grants will be configured by default and you must then set up grants in order for the user to access anything on the account.
//
func HandleUpdateUser(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateUserParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateUserResponses{}
// call the service provider
err = provider.UpdateUser(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Deletes a user. The deleted user will be immediately logged out and may no longer log in or perform any actions. All grants that user had will be lost.
//
func HandleDeleteUser(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &DeleteUserResponses{}
// call the service provider
err = provider.DeleteUser(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns the full grants structure for this user. This includes all entities on the account alongside what level of access this user has to each of them. Individual users may view their own grants at the `/profile/grants` endpoint, but will not see entities that they have no access to.
//
func HandleGetUserGrants(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetUserGrantsResponses{}
// call the service provider
err = provider.GetUserGrants(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Update the grants a user has. This can be used to give a user access to new entities or actions, or take access away. You do not need to include the grant for every entity on the account in this request; any that are not included will remain unchanged.
//
func HandleUpdateUserGrants(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateUserGrantsParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateUserGrantsResponses{}
// call the service provider
err = provider.UpdateUserGrants(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint returns a Transfer object.
//
func HandleGetTransfer(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetTransferResponses{}
// call the service provider
err = provider.GetTransfer(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This is a collection of domains that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for these to work you must own the domains and point your registrar at Linode's nameservers.
//
func HandleGetDomains(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetDomainsResponses{}
// call the service provider
err = provider.GetDomains(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Adds a new domain to Linode's DNS Manager. Linode is not a registrar, and you must own the domain before adding it here. Be sure to point your registrar to Linode's nameservers so that the records hosted here are used.
//
func HandleCreateDomain(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreateDomainParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Domain)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreateDomainResponses{}
// call the service provider
err = provider.CreateDomain(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This is a single domain that you have registered in Linode's DNS Manager. Linode is not a registrar, and in order for this domain record to work you must own the domain and point your registrar at Linode's nameservers.
//
func HandleGetDomain(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetDomainResponses{}
// call the service provider
err = provider.GetDomain(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Update information about a domain in Linode's DNS Manager.
//
func HandleUpdateDomain(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateDomainParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateDomainResponses{}
// call the service provider
err = provider.UpdateDomain(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Deletes a domain from Linode's DNS Manager. The domain will be removed from Linode's nameservers shortly after this operation completes. This also deletes all associated Domain Records.
//
func HandleDeleteDomain(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &DeleteDomainResponses{}
// call the service provider
err = provider.DeleteDomain(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns a paginated list of Images. This list includes public Images and your private Images. You can call this enpoint without authentication to get all of the public Images.
//
func HandleGetImages(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetImagesResponses{}
// call the service provider
err = provider.GetImages(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Creates a new private gold-master Image from a Linode Disk. There is no additional charge to store Images for Linode users, with a limit of 2GB per Image and 3 Images per account.
//
func HandleCreateImage(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreateImageParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Object)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreateImageResponses{}
// call the service provider
err = provider.CreateImage(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Get information about a single image.
//
func HandleGetImage(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetImageResponses{}
// call the service provider
err = provider.GetImage(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This allows you to update an private Image that you have permission to `read_write`.
//
func HandleUpdateImage(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateImageParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateImageResponses{}
// call the service provider
err = provider.UpdateImage(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Deletes an Image you have permission to `read_write`. Deleting an image is a destructive
// process and cannot be undone. Only private Images are deletable.
//
func HandleDeleteImage(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &DeleteImageResponses{}
// call the service provider
err = provider.DeleteImage(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns a paginated list of Linodes you have permission to view.
//
func HandleGetLinodeInstaces(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetLinodeInstacesResponses{}
// call the service provider
err = provider.GetLinodeInstaces(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This endpoint allows you to create a new Linode server 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. See `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, see `GET /regions` for a list
// of available regions you deploy your Linode in.
//
// Linodes can be created in a number of ways:
//
// - Using a Linode Linux Distribution image or an image you created based on another Linode
// - The Linode will be `running` after it completes `provisioning`
// - A default a 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 `password` 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
//
// - Using one of your own StackScripts or a public StackScript
// - The Linode will be `running` after it completes `provisioning`
// - Requires a compatible Linode Linux Distribution `image` to be supplied
// - see `GET /linode/stackscript/{stackscriptId}` 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
//
// - Using one of your other Linode's backups
// - The Linode will be `running` after it completes `provisioning`
// - 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
//
// - Create an empty Linode
// - The Linode will remain `offline` and must be manually started
// - see `POST /linode/instances/{linodeId}/boot`
// - Disks and Configs must be created manually
// - This is only recommended for advanced use-cases
//
func HandleCreateLinodeInstance(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreateLinodeInstanceParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Object)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreateLinodeInstanceResponses{}
// call the service provider
err = provider.CreateLinodeInstance(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Get a specific Linode by ID.
func HandleGetLinodeInstance(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetLinodeInstanceResponses{}
// call the service provider
err = provider.GetLinodeInstance(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// This allows you to update a Linode that you have permission to `read_write`.
//
func HandleUpdateLinodeInstance(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &UpdateLinodeInstanceParameters{}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &UpdateLinodeInstanceResponses{}
// call the service provider
err = provider.UpdateLinodeInstance(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Deletes a Linode you have permission to `read_write`. Deleting a Linode is a destructive
// process and cannot be undone. Additionally, deleting a Linode:
//
// * Gives up any IP addresses the Linode was assigned
// * Deletes all disks, backups, configs, etc.
// * Stops billing for the Linode and its associated services. You will be billed for time used
// within the billing period the Linode was active.
//
func HandleDeleteLinodeInstance(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &DeleteLinodeInstanceResponses{}
// call the service provider
err = provider.DeleteLinodeInstance(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Returns information about this Linode's available backups.
//
func HandleGetBackups(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetBackupsResponses{}
// call the service provider
err = provider.GetBackups(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Creates a snapshot backup of a Linode. WARNING: If you already have a snapshot this is a destructive operation. The previous snapshot will be deleted.
//
func HandleCreateSnapshot(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the parameters structure
parameters := &CreateSnapshotParameters{}
// deserialize request from post data
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&parameters.Object)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error() + "\n"))
return
}
// get request fields in path and query parameters
// instantiate the responses structure
responses := &CreateSnapshotResponses{}
// call the service provider
err = provider.CreateSnapshot(parameters, responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Cancels the backup service on the given Linode.
//
func HandleCancelBackups(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &CancelBackupsResponses{}
// call the service provider
err = provider.CancelBackups(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Enables backups for the specified Linode.
//
func HandleEnableBackups(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &EnableBackupsResponses{}
// call the service provider
err = provider.EnableBackups(responses)
if err == nil {
if responses.OK != nil {
// write the normal response
encoder := json.NewEncoder(w)
encoder.Encode(responses.OK)
return
}
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error() + "\n"))
return
}
}
// Handler
// Return information about a backup.
//
func HandleGetBackup(w http.ResponseWriter, r *http.Request) {
var err error
// instantiate the responses structure
responses := &GetBackupR
Raw
types.go
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment