vers

package module
v0.1.0-alpha.32 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 6, 2026 License: Apache-2.0 Imports: 15 Imported by: 1

README

Vers Go API Library

Go Reference

The Vers Go library provides convenient access to the Vers REST API from applications written in Go.

It is generated with Stainless.

Installation

import (
	"github.com/hdresearch/vers-sdk-go" // imported as vers
)

Or to pin the version:

go get -u 'github.com/hdresearch/vers-sdk-go@v0.1.0-alpha.32'

Requirements

This library requires Go 1.22+.

Usage

The full API of this library can be found in api.md.

package main

import (
	"context"
	"fmt"

	"github.com/hdresearch/vers-sdk-go"
	"github.com/hdresearch/vers-sdk-go/option"
)

func main() {
	client := vers.NewClient(
		option.WithAPIKey("My API Key"), // defaults to os.LookupEnv("VERS_API_KEY")
	)
	newVmResponse, err := client.Vm.NewRoot(context.TODO(), vers.VmNewRootParams{
		NewRootRequest: vers.NewRootRequestParam{
			VmConfig: vers.F(vers.NewRootRequestVmConfigParam{}),
		},
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", newVmResponse.VmID)
}
Request fields

All request parameters are wrapped in a generic Field type, which we use to distinguish zero values from null or omitted fields.

This prevents accidentally sending a zero value if you forget a required parameter, and enables explicitly sending null, false, '', or 0 on optional parameters. Any field not specified is not sent.

To construct fields with values, use the helpers String(), Int(), Float(), or most commonly, the generic F[T](). To send a null, use Null[T](), and to send a nonconforming value, use Raw[T](any). For example:

params := FooParams{
	Name: vers.F("hello"),

	// Explicitly send `"description": null`
	Description: vers.Null[string](),

	Point: vers.F(vers.Point{
		X: vers.Int(0),
		Y: vers.Int(1),

		// In cases where the API specifies a given type,
		// but you want to send something else, use `Raw`:
		Z: vers.Raw[int64](0.01), // sends a float
	}),
}
Response objects

All fields in response structs are value types (not pointers or wrappers).

If a given field is null, not present, or invalid, the corresponding field will simply be its zero value.

All response structs also include a special JSON field, containing more detailed information about each property, which you can use like so:

if res.Name == "" {
	// true if `"name"` is either not present or explicitly null
	res.JSON.Name.IsNull()

	// true if the `"name"` key was not present in the response JSON at all
	res.JSON.Name.IsMissing()

	// When the API returns data that cannot be coerced to the expected type:
	if res.JSON.Name.IsInvalid() {
		raw := res.JSON.Name.Raw()

		legacyName := struct{
			First string `json:"first"`
			Last  string `json:"last"`
		}{}
		json.Unmarshal([]byte(raw), &legacyName)
		name = legacyName.First + " " + legacyName.Last
	}
}

These .JSON structs also include an Extras map containing any properties in the json response that were not specified in the struct. This can be useful for API features not yet present in the SDK.

body := res.JSON.ExtraFields["my_unexpected_field"].Raw()
RequestOptions

This library uses the functional options pattern. Functions defined in the option package return a RequestOption, which is a closure that mutates a RequestConfig. These options can be supplied to the client or at individual requests. For example:

client := vers.NewClient(
	// Adds a header to every request made by the client
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Vm.NewRoot(context.TODO(), ...,
	// Override the header
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Add an undocumented field to the request body, using sjson syntax
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

See the full list of request options.

Pagination

This library provides some conveniences for working with paginated list endpoints.

You can use .ListAutoPaging() methods to iterate through items across all pages:

Or you can use simple .List() methods to fetch a single page and receive a standard response object with additional helper methods like .GetNextPage(), e.g.:

Errors

When the API returns a non-success status code, we return an error with type *vers.Error. This contains the StatusCode, *http.Request, and *http.Response values of the request, as well as the JSON of the error body (much like other response objects in the SDK).

To handle errors, we recommend that you use the errors.As pattern:

_, err := client.Vm.NewRoot(context.TODO(), vers.VmNewRootParams{
	NewRootRequest: vers.NewRootRequestParam{
		VmConfig: vers.F(vers.NewRootRequestVmConfigParam{}),
	},
})
if err != nil {
	var apierr *vers.Error
	if errors.As(err, &apierr) {
		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
	}
	panic(err.Error()) // GET "/api/v1/vm/new_root": 400 Bad Request { ... }
}

When other errors occur, they are returned unwrapped; for example, if HTTP transport fails, you might receive *url.Error wrapping *net.OpError.

Timeouts

Requests do not time out by default; use context to configure a timeout for a request lifecycle.

Note that if a request is retried, the context timeout does not start over. To set a per-retry timeout, use option.WithRequestTimeout().

// This sets the timeout for the request, including all the retries.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
client.Vm.NewRoot(
	ctx,
	vers.VmNewRootParams{
		NewRootRequest: vers.NewRootRequestParam{
			VmConfig: vers.F(vers.NewRootRequestVmConfigParam{}),
		},
	},
	// This sets the per-retry timeout
	option.WithRequestTimeout(20*time.Second),
)
File uploads

Request parameters that correspond to file uploads in multipart requests are typed as param.Field[io.Reader]. The contents of the io.Reader will by default be sent as a multipart form part with the file name of "anonymous_file" and content-type of "application/octet-stream".

The file name and content-type can be customized by implementing Name() string or ContentType() string on the run-time type of io.Reader. Note that os.File implements Name() string, so a file returned by os.Open will be sent with the file name on disk.

We also provide a helper vers.FileParam(reader io.Reader, filename string, contentType string) which can be used to wrap any io.Reader with the appropriate file name and content type.

Retries

Certain errors will be automatically retried 2 times by default, with a short exponential backoff. We retry by default all connection errors, 408 Request Timeout, 409 Conflict, 429 Rate Limit, and >=500 Internal errors.

You can use the WithMaxRetries option to configure or disable this:

// Configure the default for all requests:
client := vers.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Override per-request:
client.Vm.NewRoot(
	context.TODO(),
	vers.VmNewRootParams{
		NewRootRequest: vers.NewRootRequestParam{
			VmConfig: vers.F(vers.NewRootRequestVmConfigParam{}),
		},
	},
	option.WithMaxRetries(5),
)
Accessing raw response data (e.g. response headers)

You can access the raw HTTP response data by using the option.WithResponseInto() request option. This is useful when you need to examine response headers, status codes, or other details.

// Create a variable to store the HTTP response
var response *http.Response
newVmResponse, err := client.Vm.NewRoot(
	context.TODO(),
	vers.VmNewRootParams{
		NewRootRequest: vers.NewRootRequestParam{
			VmConfig: vers.F(vers.NewRootRequestVmConfigParam{}),
		},
	},
	option.WithResponseInto(&response),
)
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", newVmResponse)

fmt.Printf("Status Code: %d\n", response.StatusCode)
fmt.Printf("Headers: %+#v\n", response.Header)
Making custom/undocumented requests

This library is typed for convenient access to the documented API. If you need to access undocumented endpoints, params, or response properties, the library can still be used.

Undocumented endpoints

To make requests to undocumented endpoints, you can use client.Get, client.Post, and other HTTP verbs. RequestOptions on the client, such as retries, will be respected when making these requests.

var (
    // params can be an io.Reader, a []byte, an encoding/json serializable object,
    // or a "…Params" struct defined in this library.
    params map[string]interface{}

    // result can be an []byte, *http.Response, a encoding/json deserializable object,
    // or a model defined in this library.
    result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
    …
}
Undocumented request params

To make requests using undocumented parameters, you may use either the option.WithQuerySet() or the option.WithJSONSet() methods.

params := FooNewParams{
    ID:   vers.F("id_xxxx"),
    Data: vers.F(FooNewParamsData{
        FirstName: vers.F("John"),
    }),
}
client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))
Undocumented response properties

To access undocumented response properties, you may either access the raw JSON of the response as a string with result.JSON.RawJSON(), or get the raw JSON of a particular field on the result with result.JSON.Foo.Raw().

Any fields that are not present on the response struct will be saved and can be accessed by result.JSON.ExtraFields() which returns the extra fields as a map[string]Field.

Middleware

We provide option.WithMiddleware which applies the given middleware to requests.

func Logger(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
	// Before the request
	start := time.Now()
	LogReq(req)

	// Forward the request to the next handler
	res, err = next(req)

	// Handle stuff after the request
	end := time.Now()
	LogRes(res, err, start - end)

    return res, err
}

client := vers.NewClient(
	option.WithMiddleware(Logger),
)

When multiple middlewares are provided as variadic arguments, the middlewares are applied left to right. If option.WithMiddleware is given multiple times, for example first in the client then the method, the middleware in the client will run first and the middleware given in the method will run next.

You may also replace the default http.Client with option.WithHTTPClient(client). Only one http client is accepted (this overwrites any previous client) and receives requests after any middleware has been applied.

Semantic versioning

This package generally follows SemVer conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes to library internals which are technically public but not intended or documented for external use. (Please open a GitHub issue to let us know if you are relying on such internals.)
  2. Changes that we do not expect to impact the vast majority of users in practice.

We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

We are keen for your feedback; please open an issue with questions, bugs, or suggestions.

Contributing

See the contributing documentation.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Bool 

func Bool(value bool) param.Field[bool]

Bool is a param field helper which helps specify bools.

func DefaultClientOptions 

func DefaultClientOptions() []option.RequestOption

DefaultClientOptions read from the environment (VERS_API_KEY, VERS_BASE_URL). This should be used to initialize new clients.

func F 

func F[T any](value T) param.Field[T]

F is a param field helper used to initialize a param.Field generic struct. This helps specify null, zero values, and overrides, as well as normal values. You can read more about this in our README.

func FileParam 

func FileParam(reader io.Reader, filename string, contentType string) param.Field[io.Reader]

FileParam is a param field helper which helps files with a mime content-type.

func Float 

func Float(value float64) param.Field[float64]

Float is a param field helper which helps specify floats.

func Int 

func Int(value int64) param.Field[int64]

Int is a param field helper which helps specify integers. This is particularly helpful when specifying integer constants for fields.

func Null 

func Null[T any]() param.Field[T]

Null is a param field helper which explicitly sends null to the API.

func Raw 

func Raw[T any](value any) param.Field[T]

Raw is a param field helper for specifying values for fields when the type you are looking to send is different from the type that is specified in the SDK. For example, if the type of the field is an integer, but you want to send a float, you could do that by setting the corresponding field with Raw[int](0.5).

func String 

func String(value string) param.Field[string]

String is a param field helper which helps specify strings.

Types

type Client 

type Client struct {
	Options            []option.RequestOption
	Vm                 *VmService
	Commits            *CommitService
	CommitTags         *CommitTagService
	Repositories       *RepositoryService
	PublicRepositories *PublicRepositoryService
}

Client creates a struct with services and top level methods that help with interacting with the vers API. You should not instantiate this client directly, and instead use the NewClient method instead.

func NewClient 

func NewClient(opts ...option.RequestOption) (r *Client)

NewClient generates a new client with the default option read from the environment (VERS_API_KEY, VERS_BASE_URL). The option passed in as arguments are applied after these default arguments, and all option will be passed down to the services and requests that this client makes.

func (*Client) Delete 

func (r *Client) Delete(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Delete makes a DELETE request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Execute 

func (r *Client) Execute(ctx context.Context, method string, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Execute makes a request with the given context, method, URL, request params, response, and request options. This is useful for hitting undocumented endpoints while retaining the base URL, auth, retries, and other options from the client.

If a byte slice or an io.Reader is supplied to params, it will be used as-is for the request body.

The params is by default serialized into the body using encoding/json. If your type implements a MarshalJSON function, it will be used instead to serialize the request. If a URLQuery method is implemented, the returned url.Values will be used as query strings to the url.

If your params struct uses param.Field, you must provide either [MarshalJSON], [URLQuery], and/or [MarshalForm] functions. It is undefined behavior to use a struct uses param.Field without specifying how it is serialized.

Any "…Params" object defined in this library can be used as the request argument. Note that 'path' arguments will not be forwarded into the url.

The response body will be deserialized into the res variable, depending on its type:

  • A pointer to a *http.Response is populated by the raw response.
  • A pointer to a byte array will be populated with the contents of the request body.
  • A pointer to any other type uses this library's default JSON decoding, which respects UnmarshalJSON if it is defined on the type.
  • A nil value will not read the response body.

For even greater flexibility, see option.WithResponseInto and option.WithResponseBodyInto.

func (*Client) Get 

func (r *Client) Get(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Get makes a GET request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Patch 

func (r *Client) Patch(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Patch makes a PATCH request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Post 

func (r *Client) Post(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Post makes a POST request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Put 

func (r *Client) Put(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error

Put makes a PUT request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

type CommitInfo 

type CommitInfo struct {
	CommitID            string         `json:"commit_id" api:"required"`
	CreatedAt           string         `json:"created_at" api:"required"`
	IsPublic            bool           `json:"is_public" api:"required"`
	Name                string         `json:"name" api:"required"`
	OwnerID             string         `json:"owner_id" api:"required"`
	Description         string         `json:"description" api:"nullable"`
	GrandparentCommitID string         `json:"grandparent_commit_id" api:"nullable"`
	ParentVmID          string         `json:"parent_vm_id" api:"nullable"`
	JSON                commitInfoJSON `json:"-"`
}

func (*CommitInfo) UnmarshalJSON 

func (r *CommitInfo) UnmarshalJSON(data []byte) (err error)

type CommitListParentsResponse 

type CommitListParentsResponse struct {
	ID        string    `json:"id" api:"required" format:"uuid"`
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Whether this commit is publicly accessible (readable/restorable by anyone).
	IsPublic bool   `json:"is_public" api:"required"`
	Name     string `json:"name" api:"required"`
	// api key id.
	OwnerID     string `json:"owner_id" api:"required" format:"uuid"`
	Description string `json:"description" api:"nullable"`
	// The commit that this commit's parent VM was started from, if any. Intended to
	// optimize traversing the commit tree.
	GrandparentCommitID string `json:"grandparent_commit_id" api:"nullable" format:"uuid"`
	// The VM that this commit was created from, if any.
	ParentVmID string                        `json:"parent_vm_id" api:"nullable" format:"uuid"`
	JSON       commitListParentsResponseJSON `json:"-"`
}

func (*CommitListParentsResponse) UnmarshalJSON 

func (r *CommitListParentsResponse) UnmarshalJSON(data []byte) (err error)

type CommitService 

type CommitService struct {
	Options []option.RequestOption
}

CommitService contains methods and other services that help with interacting with the vers API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCommitService method instead.

func NewCommitService 

func NewCommitService(opts ...option.RequestOption) (r *CommitService)

NewCommitService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CommitService) Delete 

func (r *CommitService) Delete(ctx context.Context, commitID string, opts ...option.RequestOption) (err error)

func (*CommitService) List 

func (r *CommitService) List(ctx context.Context, opts ...option.RequestOption) (res *ListCommitsResponse, err error)

func (*CommitService) ListParents 

func (r *CommitService) ListParents(ctx context.Context, commitID string, opts ...option.RequestOption) (res *[]CommitListParentsResponse, err error)

func (*CommitService) ListPublic 

func (r *CommitService) ListPublic(ctx context.Context, opts ...option.RequestOption) (res *ListCommitsResponse, err error)

func (*CommitService) Update 

func (r *CommitService) Update(ctx context.Context, commitID string, body CommitUpdateParams, opts ...option.RequestOption) (res *CommitInfo, err error)

type CommitTagNewParams 

type CommitTagNewParams struct {
	// Request body for POST /api/v1/commit_tags
	CreateTagRequest CreateTagRequestParam `json:"create_tag_request" api:"required"`
}

func (CommitTagNewParams) MarshalJSON 

func (r CommitTagNewParams) MarshalJSON() (data []byte, err error)

type CommitTagService 

type CommitTagService struct {
	Options []option.RequestOption
}

CommitTagService contains methods and other services that help with interacting with the vers API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCommitTagService method instead.

func NewCommitTagService 

func NewCommitTagService(opts ...option.RequestOption) (r *CommitTagService)

NewCommitTagService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CommitTagService) Delete 

func (r *CommitTagService) Delete(ctx context.Context, tagName string, opts ...option.RequestOption) (err error)

func (*CommitTagService) Get 

func (r *CommitTagService) Get(ctx context.Context, tagName string, opts ...option.RequestOption) (res *TagInfo, err error)

func (*CommitTagService) List 

func (r *CommitTagService) List(ctx context.Context, opts ...option.RequestOption) (res *ListTagsResponse, err error)

func (*CommitTagService) New 

func (r *CommitTagService) New(ctx context.Context, body CommitTagNewParams, opts ...option.RequestOption) (res *CreateTagResponse, err error)

func (*CommitTagService) Update 

func (r *CommitTagService) Update(ctx context.Context, tagName string, body CommitTagUpdateParams, opts ...option.RequestOption) (err error)

type CommitTagUpdateParams 

type CommitTagUpdateParams struct {
	// Request body for PATCH /api/v1/commit_tags/{tag_name}
	//
	// For `description`:
	//
	// - Field absent from JSON → don't change the description
	// - Field present as `null` → clear the description
	// - Field present as `"text"` → set the description to "text"
	UpdateTagRequest UpdateTagRequestParam `json:"update_tag_request" api:"required"`
}

func (CommitTagUpdateParams) MarshalJSON 

func (r CommitTagUpdateParams) MarshalJSON() (data []byte, err error)

type CommitUpdateParams 

type CommitUpdateParams struct {
	// Request body for PATCH /commits/{commit_id}
	UpdateCommitRequest UpdateCommitRequestParam `json:"update_commit_request" api:"required"`
}

func (CommitUpdateParams) MarshalJSON 

func (r CommitUpdateParams) MarshalJSON() (data []byte, err error)

type CreateRepoTagRequestParam 

type CreateRepoTagRequestParam struct {
	// The commit ID this tag should point to
	CommitID param.Field[string] `json:"commit_id" api:"required" format:"uuid"`
	// The tag name (e.g. "latest", "v1.0")
	TagName param.Field[string] `json:"tag_name" api:"required"`
	// Optional description of what this tag represents
	Description param.Field[string] `json:"description"`
}

Request body for creating a tag within a repository: POST /api/v1/repositories/{repo_name}/tags

func (CreateRepoTagRequestParam) MarshalJSON 

func (r CreateRepoTagRequestParam) MarshalJSON() (data []byte, err error)

type CreateRepoTagResponse 

type CreateRepoTagResponse struct {
	// The commit ID this tag points to
	CommitID string `json:"commit_id" api:"required" format:"uuid"`
	// Full reference in image_name:tag format
	Reference string `json:"reference" api:"required"`
	// The ID of the newly created tag
	TagID string                    `json:"tag_id" api:"required" format:"uuid"`
	JSON  createRepoTagResponseJSON `json:"-"`
}

Response body for POST /api/v1/repositories/{repo_name}/tags

func (*CreateRepoTagResponse) UnmarshalJSON 

func (r *CreateRepoTagResponse) UnmarshalJSON(data []byte) (err error)

type CreateRepositoryRequestParam 

type CreateRepositoryRequestParam struct {
	// The name of the repository (alphanumeric, hyphens, underscores, dots, 1-64
	// chars)
	Name param.Field[string] `json:"name" api:"required"`
	// Optional description of the repository
	Description param.Field[string] `json:"description"`
}

Request body for POST /api/v1/repositories

func (CreateRepositoryRequestParam) MarshalJSON 

func (r CreateRepositoryRequestParam) MarshalJSON() (data []byte, err error)

type CreateRepositoryResponse 

type CreateRepositoryResponse struct {
	// The name of the repository
	Name string `json:"name" api:"required"`
	// The ID of the newly created repository
	RepoID string                       `json:"repo_id" api:"required" format:"uuid"`
	JSON   createRepositoryResponseJSON `json:"-"`
}

Response body for POST /api/v1/repositories

func (*CreateRepositoryResponse) UnmarshalJSON 

func (r *CreateRepositoryResponse) UnmarshalJSON(data []byte) (err error)

type CreateTagRequestParam 

type CreateTagRequestParam struct {
	// The commit ID this tag should point to
	CommitID param.Field[string] `json:"commit_id" api:"required" format:"uuid"`
	// The name of the tag (alphanumeric, hyphens, underscores, dots, 1-64 chars)
	TagName param.Field[string] `json:"tag_name" api:"required"`
	// Optional description of what this tag represents
	Description param.Field[string] `json:"description"`
}

Request body for POST /api/v1/commit_tags

func (CreateTagRequestParam) MarshalJSON 

func (r CreateTagRequestParam) MarshalJSON() (data []byte, err error)

type CreateTagResponse 

type CreateTagResponse struct {
	// The commit ID this tag points to
	CommitID string `json:"commit_id" api:"required" format:"uuid"`
	// The ID of the newly created tag
	TagID string `json:"tag_id" api:"required" format:"uuid"`
	// The name of the tag
	TagName string                `json:"tag_name" api:"required"`
	JSON    createTagResponseJSON `json:"-"`
}

Response body for POST /api/v1/commit_tags

func (*CreateTagResponse) UnmarshalJSON 

func (r *CreateTagResponse) UnmarshalJSON(data []byte) (err error)

type Error 

type Error = apierror.Error

type ForkRepositoryRequestParam 

type ForkRepositoryRequestParam struct {
	// The organization that owns the source public repository
	SourceOrg param.Field[string] `json:"source_org" api:"required"`
	// The source repository name
	SourceRepo param.Field[string] `json:"source_repo" api:"required"`
	// The tag to fork (e.g. "latest", "v1.0")
	SourceTag param.Field[string] `json:"source_tag" api:"required"`
	// Name for the new repository in your org (defaults to source_repo if omitted)
	RepoName param.Field[string] `json:"repo_name"`
	// Tag name in the new repo (defaults to source_tag if omitted)
	TagName param.Field[string] `json:"tag_name"`
}

Request body for POST /api/v1/repositories/fork

func (ForkRepositoryRequestParam) MarshalJSON 

func (r ForkRepositoryRequestParam) MarshalJSON() (data []byte, err error)

type ForkRepositoryResponse 

type ForkRepositoryResponse struct {
	// The new commit in your org (snapshot of the forked VM)
	CommitID string `json:"commit_id" api:"required" format:"uuid"`
	// Full reference: repo_name:tag_name
	Reference string `json:"reference" api:"required"`
	// The new repository name in your org
	RepoName string `json:"repo_name" api:"required"`
	// The tag name pointing to the forked commit
	TagName string `json:"tag_name" api:"required"`
	// The new VM that was created from the fork
	VmID string                     `json:"vm_id" api:"required"`
	JSON forkRepositoryResponseJSON `json:"-"`
}

Response body for POST /api/v1/repositories/fork

func (*ForkRepositoryResponse) UnmarshalJSON 

func (r *ForkRepositoryResponse) UnmarshalJSON(data []byte) (err error)

type ListCommitsResponse 

type ListCommitsResponse struct {
	Commits []CommitInfo            `json:"commits" api:"required"`
	Limit   int64                   `json:"limit" api:"required"`
	Offset  int64                   `json:"offset" api:"required"`
	Total   int64                   `json:"total" api:"required"`
	JSON    listCommitsResponseJSON `json:"-"`
}

func (*ListCommitsResponse) UnmarshalJSON 

func (r *ListCommitsResponse) UnmarshalJSON(data []byte) (err error)

type ListPublicRepositoriesResponse 

type ListPublicRepositoriesResponse struct {
	Repositories []PublicRepositoryInfo             `json:"repositories" api:"required"`
	JSON         listPublicRepositoriesResponseJSON `json:"-"`
}

Response body for GET /api/v1/public/repositories

func (*ListPublicRepositoriesResponse) UnmarshalJSON 

func (r *ListPublicRepositoriesResponse) UnmarshalJSON(data []byte) (err error)

type ListRepoTagsResponse 

type ListRepoTagsResponse struct {
	// The repository name
	Repository string `json:"repository" api:"required"`
	// List of tags in this repository
	Tags []RepoTagInfo            `json:"tags" api:"required"`
	JSON listRepoTagsResponseJSON `json:"-"`
}

Response body for GET /api/v1/repositories/{repo_name}/tags

func (*ListRepoTagsResponse) UnmarshalJSON 

func (r *ListRepoTagsResponse) UnmarshalJSON(data []byte) (err error)

type ListRepositoriesResponse 

type ListRepositoriesResponse struct {
	// List of all repositories in the user's organization
	Repositories []RepositoryInfo             `json:"repositories" api:"required"`
	JSON         listRepositoriesResponseJSON `json:"-"`
}

Response body for GET /api/v1/repositories

func (*ListRepositoriesResponse) UnmarshalJSON 

func (r *ListRepositoriesResponse) UnmarshalJSON(data []byte) (err error)

type ListTagsResponse 

type ListTagsResponse struct {
	// List of all tags in the user's organization
	Tags []TagInfo            `json:"tags" api:"required"`
	JSON listTagsResponseJSON `json:"-"`
}

Response body for GET /api/v1/commit_tags

func (*ListTagsResponse) UnmarshalJSON 

func (r *ListTagsResponse) UnmarshalJSON(data []byte) (err error)

type NewRootRequestParam 

type NewRootRequestParam struct {
	// Struct representing configuration options common to all VMs
	VmConfig param.Field[NewRootRequestVmConfigParam] `json:"vm_config" api:"required"`
}

func (NewRootRequestParam) MarshalJSON 

func (r NewRootRequestParam) MarshalJSON() (data []byte, err error)

type NewRootRequestVmConfigParam 

type NewRootRequestVmConfigParam struct {
	// The disk size, in MiB.
	FsSizeMib param.Field[int64] `json:"fs_size_mib"`
	// The filesystem base image name. Currently, must be 'default'
	ImageName param.Field[string] `json:"image_name"`
	// The kernel name. Currently, must be 'default.bin'
	KernelName param.Field[string] `json:"kernel_name"`
	// The RAM size, in MiB.
	MemSizeMib param.Field[int64] `json:"mem_size_mib"`
	// How many vCPUs to allocate to this VM (and its children)
	VcpuCount param.Field[int64] `json:"vcpu_count"`
}

Struct representing configuration options common to all VMs

func (NewRootRequestVmConfigParam) MarshalJSON 

func (r NewRootRequestVmConfigParam) MarshalJSON() (data []byte, err error)

type NewVmResponse 

type NewVmResponse struct {
	VmID string            `json:"vm_id" api:"required"`
	JSON newVmResponseJSON `json:"-"`
}

Response body for new VM requests (new_root, from_commit, branch)

func (*NewVmResponse) UnmarshalJSON 

func (r *NewVmResponse) UnmarshalJSON(data []byte) (err error)

type NewVmsResponse 

type NewVmsResponse struct {
	Vms  []NewVmResponse    `json:"vms" api:"required"`
	JSON newVmsResponseJSON `json:"-"`
}

func (*NewVmsResponse) UnmarshalJSON 

func (r *NewVmsResponse) UnmarshalJSON(data []byte) (err error)

type PublicRepositoryInfo 

type PublicRepositoryInfo struct {
	// When the repository was created
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Full reference: org_name/repo_name
	FullName string `json:"full_name" api:"required"`
	// The repository name
	Name string `json:"name" api:"required"`
	// The owning organization's name (namespace)
	OrgName string `json:"org_name" api:"required"`
	// The repository's unique identifier
	RepoID string `json:"repo_id" api:"required" format:"uuid"`
	// Optional description
	Description string                   `json:"description" api:"nullable"`
	JSON        publicRepositoryInfoJSON `json:"-"`
}

Public repository information (includes owner org name for namespacing)

func (*PublicRepositoryInfo) UnmarshalJSON 

func (r *PublicRepositoryInfo) UnmarshalJSON(data []byte) (err error)

type PublicRepositoryService 

type PublicRepositoryService struct {
	Options []option.RequestOption
}

PublicRepositoryService contains methods and other services that help with interacting with the vers API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPublicRepositoryService method instead.

func NewPublicRepositoryService 

func NewPublicRepositoryService(opts ...option.RequestOption) (r *PublicRepositoryService)

NewPublicRepositoryService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PublicRepositoryService) Get 

func (r *PublicRepositoryService) Get(ctx context.Context, orgName string, repoName string, opts ...option.RequestOption) (res *PublicRepositoryInfo, err error)

func (*PublicRepositoryService) GetTag 

func (r *PublicRepositoryService) GetTag(ctx context.Context, orgName string, repoName string, tagName string, opts ...option.RequestOption) (res *RepoTagInfo, err error)

func (*PublicRepositoryService) List 

func (r *PublicRepositoryService) List(ctx context.Context, opts ...option.RequestOption) (res *ListPublicRepositoriesResponse, err error)

func (*PublicRepositoryService) ListTags 

func (r *PublicRepositoryService) ListTags(ctx context.Context, orgName string, repoName string, opts ...option.RequestOption) (res *ListRepoTagsResponse, err error)

type RepoTagInfo 

type RepoTagInfo struct {
	// The commit ID this tag currently points to
	CommitID string `json:"commit_id" api:"required" format:"uuid"`
	// When the tag was created
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Full reference in image_name:tag format
	Reference string `json:"reference" api:"required"`
	// The tag's unique identifier
	TagID string `json:"tag_id" api:"required" format:"uuid"`
	// The tag name
	TagName string `json:"tag_name" api:"required"`
	// When the tag was last updated
	UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
	// Optional description
	Description string          `json:"description" api:"nullable"`
	JSON        repoTagInfoJSON `json:"-"`
}

Tag information within a repository context

func (*RepoTagInfo) UnmarshalJSON 

func (r *RepoTagInfo) UnmarshalJSON(data []byte) (err error)

type RepositoryForkParams 

type RepositoryForkParams struct {
	// Request body for POST /api/v1/repositories/fork
	ForkRepositoryRequest ForkRepositoryRequestParam `json:"fork_repository_request" api:"required"`
}

func (RepositoryForkParams) MarshalJSON 

func (r RepositoryForkParams) MarshalJSON() (data []byte, err error)

type RepositoryInfo 

type RepositoryInfo struct {
	// When the repository was created
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Whether this repository is publicly visible
	IsPublic bool `json:"is_public" api:"required"`
	// The repository name
	Name string `json:"name" api:"required"`
	// The repository's unique identifier
	RepoID string `json:"repo_id" api:"required" format:"uuid"`
	// Optional description
	Description string             `json:"description" api:"nullable"`
	JSON        repositoryInfoJSON `json:"-"`
}

Repository information returned in list and get operations

func (*RepositoryInfo) UnmarshalJSON 

func (r *RepositoryInfo) UnmarshalJSON(data []byte) (err error)

type RepositoryNewParams 

type RepositoryNewParams struct {
	// Request body for POST /api/v1/repositories
	CreateRepositoryRequest CreateRepositoryRequestParam `json:"create_repository_request" api:"required"`
}

func (RepositoryNewParams) MarshalJSON 

func (r RepositoryNewParams) MarshalJSON() (data []byte, err error)

type RepositoryNewTagParams 

type RepositoryNewTagParams struct {
	// Request body for creating a tag within a repository: POST
	// /api/v1/repositories/{repo_name}/tags
	CreateRepoTagRequest CreateRepoTagRequestParam `json:"create_repo_tag_request" api:"required"`
}

func (RepositoryNewTagParams) MarshalJSON 

func (r RepositoryNewTagParams) MarshalJSON() (data []byte, err error)

type RepositoryService 

type RepositoryService struct {
	Options []option.RequestOption
}

RepositoryService contains methods and other services that help with interacting with the vers API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRepositoryService method instead.

func NewRepositoryService 

func NewRepositoryService(opts ...option.RequestOption) (r *RepositoryService)

NewRepositoryService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*RepositoryService) Delete 

func (r *RepositoryService) Delete(ctx context.Context, repoName string, opts ...option.RequestOption) (err error)

func (*RepositoryService) DeleteTag 

func (r *RepositoryService) DeleteTag(ctx context.Context, repoName string, tagName string, opts ...option.RequestOption) (err error)

func (*RepositoryService) Fork 

func (r *RepositoryService) Fork(ctx context.Context, body RepositoryForkParams, opts ...option.RequestOption) (res *ForkRepositoryResponse, err error)

func (*RepositoryService) Get 

func (r *RepositoryService) Get(ctx context.Context, repoName string, opts ...option.RequestOption) (res *RepositoryInfo, err error)

func (*RepositoryService) GetTag 

func (r *RepositoryService) GetTag(ctx context.Context, repoName string, tagName string, opts ...option.RequestOption) (res *RepoTagInfo, err error)

func (*RepositoryService) List 

func (r *RepositoryService) List(ctx context.Context, opts ...option.RequestOption) (res *ListRepositoriesResponse, err error)

func (*RepositoryService) ListTags 

func (r *RepositoryService) ListTags(ctx context.Context, repoName string, opts ...option.RequestOption) (res *ListRepoTagsResponse, err error)

func (*RepositoryService) New 

func (r *RepositoryService) New(ctx context.Context, body RepositoryNewParams, opts ...option.RequestOption) (res *CreateRepositoryResponse, err error)

func (*RepositoryService) NewTag 

func (r *RepositoryService) NewTag(ctx context.Context, repoName string, body RepositoryNewTagParams, opts ...option.RequestOption) (res *CreateRepoTagResponse, err error)

func (*RepositoryService) SetVisibility 

func (r *RepositoryService) SetVisibility(ctx context.Context, repoName string, body RepositorySetVisibilityParams, opts ...option.RequestOption) (err error)

func (*RepositoryService) UpdateTag 

func (r *RepositoryService) UpdateTag(ctx context.Context, repoName string, tagName string, body RepositoryUpdateTagParams, opts ...option.RequestOption) (err error)

type RepositorySetVisibilityParams 

type RepositorySetVisibilityParams struct {
	// Request body for PATCH /api/v1/repositories/{repo_name}/visibility
	SetRepositoryVisibilityRequest SetRepositoryVisibilityRequestParam `json:"set_repository_visibility_request" api:"required"`
}

func (RepositorySetVisibilityParams) MarshalJSON 

func (r RepositorySetVisibilityParams) MarshalJSON() (data []byte, err error)

type RepositoryUpdateTagParams 

type RepositoryUpdateTagParams struct {
	// Request body for PATCH /api/v1/repositories/{repo_name}/tags/{tag_name}
	UpdateRepoTagRequest UpdateRepoTagRequestParam `json:"update_repo_tag_request" api:"required"`
}

func (RepositoryUpdateTagParams) MarshalJSON 

func (r RepositoryUpdateTagParams) MarshalJSON() (data []byte, err error)

type SetRepositoryVisibilityRequestParam 

type SetRepositoryVisibilityRequestParam struct {
	// Whether the repository should be publicly visible
	IsPublic param.Field[bool] `json:"is_public" api:"required"`
}

Request body for PATCH /api/v1/repositories/{repo_name}/visibility

func (SetRepositoryVisibilityRequestParam) MarshalJSON 

func (r SetRepositoryVisibilityRequestParam) MarshalJSON() (data []byte, err error)

type TagInfo 

type TagInfo struct {
	// The commit ID this tag currently points to
	CommitID string `json:"commit_id" api:"required" format:"uuid"`
	// When the tag was created
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// The tag's unique identifier
	TagID string `json:"tag_id" api:"required" format:"uuid"`
	// The name of the tag
	TagName string `json:"tag_name" api:"required"`
	// When the tag was last updated (moved to different commit or description changed)
	UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
	// Optional description of what this tag represents
	Description string      `json:"description" api:"nullable"`
	JSON        tagInfoJSON `json:"-"`
}

Tag information returned in list and get operations

func (*TagInfo) UnmarshalJSON 

func (r *TagInfo) UnmarshalJSON(data []byte) (err error)

type UpdateCommitRequestParam 

type UpdateCommitRequestParam struct {
	IsPublic param.Field[bool] `json:"is_public" api:"required"`
}

Request body for PATCH /commits/{commit_id}

func (UpdateCommitRequestParam) MarshalJSON 

func (r UpdateCommitRequestParam) MarshalJSON() (data []byte, err error)

type UpdateRepoTagRequestParam 

type UpdateRepoTagRequestParam struct {
	// Optional new commit ID to move the tag to
	CommitID param.Field[string] `json:"commit_id" format:"uuid"`
	// Optional new description for the tag. Send `null` to clear.
	Description param.Field[string] `json:"description"`
}

Request body for PATCH /api/v1/repositories/{repo_name}/tags/{tag_name}

func (UpdateRepoTagRequestParam) MarshalJSON 

func (r UpdateRepoTagRequestParam) MarshalJSON() (data []byte, err error)

type UpdateTagRequestParam 

type UpdateTagRequestParam struct {
	// Optional new commit ID to move the tag to
	CommitID param.Field[string] `json:"commit_id" format:"uuid"`
	// Optional new description for the tag. Send `null` to clear an existing
	// description.
	Description param.Field[string] `json:"description"`
}

Request body for PATCH /api/v1/commit_tags/{tag_name}

For `description`:

- Field absent from JSON → don't change the description - Field present as `null` → clear the description - Field present as `"text"` → set the description to "text"

func (UpdateTagRequestParam) MarshalJSON 

func (r UpdateTagRequestParam) MarshalJSON() (data []byte, err error)

type Vm 

type Vm struct {
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	OwnerID   string    `json:"owner_id" api:"required" format:"uuid"`
	// The state of a VM
	State VmState `json:"state" api:"required"`
	VmID  string  `json:"vm_id" api:"required" format:"uuid"`
	JSON  vmJSON  `json:"-"`
}

func (*Vm) UnmarshalJSON 

func (r *Vm) UnmarshalJSON(data []byte) (err error)

type VmBranchByCommitParams 

type VmBranchByCommitParams struct {
	// Number of VMs to branch (optional; default 1)
	Count param.Field[int64] `query:"count"`
}

func (VmBranchByCommitParams) URLQuery 

func (r VmBranchByCommitParams) URLQuery() (v url.Values)

URLQuery serializes VmBranchByCommitParams's query parameters as `url.Values`.

type VmBranchByTagParams 

type VmBranchByTagParams struct {
	// Number of VMs to branch (optional; default 1)
	Count param.Field[int64] `query:"count"`
}

func (VmBranchByTagParams) URLQuery 

func (r VmBranchByTagParams) URLQuery() (v url.Values)

URLQuery serializes VmBranchByTagParams's query parameters as `url.Values`.

type VmBranchByVmParams 

type VmBranchByVmParams struct {
	// Number of VMs to branch (optional; default 1)
	Count param.Field[int64] `query:"count"`
	// If true, keep VM paused after commit
	KeepPaused param.Field[bool] `query:"keep_paused"`
	// If true, immediately return an error if VM is booting instead of waiting
	SkipWaitBoot param.Field[bool] `query:"skip_wait_boot"`
}

func (VmBranchByVmParams) URLQuery 

func (r VmBranchByVmParams) URLQuery() (v url.Values)

URLQuery serializes VmBranchByVmParams's query parameters as `url.Values`.

type VmBranchParams 

type VmBranchParams struct {
	// Number of VMs to branch (optional; default 1)
	Count param.Field[int64] `query:"count"`
	// If true, keep VM paused after commit. Only applicable when branching a VM ID.
	KeepPaused param.Field[bool] `query:"keep_paused"`
	// If true, immediately return an error if VM is booting instead of waiting. Only
	// applicable when branching a VM ID.
	SkipWaitBoot param.Field[bool] `query:"skip_wait_boot"`
}

func (VmBranchParams) URLQuery 

func (r VmBranchParams) URLQuery() (v url.Values)

URLQuery serializes VmBranchParams's query parameters as `url.Values`.

type VmCommitParams 

type VmCommitParams struct {
	// If true, keep VM paused after commit
	KeepPaused param.Field[bool] `query:"keep_paused"`
	// If true, return an error immediately if the VM is still booting. Default: false
	SkipWaitBoot param.Field[bool] `query:"skip_wait_boot"`
}

func (VmCommitParams) URLQuery 

func (r VmCommitParams) URLQuery() (v url.Values)

URLQuery serializes VmCommitParams's query parameters as `url.Values`.

type VmCommitResponse 

type VmCommitResponse struct {
	// The UUID of the newly-created commit
	CommitID string               `json:"commit_id" api:"required" format:"uuid"`
	JSON     vmCommitResponseJSON `json:"-"`
}

The response body for POST /api/vm/{vm_id}/commit

func (*VmCommitResponse) UnmarshalJSON 

func (r *VmCommitResponse) UnmarshalJSON(data []byte) (err error)

type VmDeleteParams 

type VmDeleteParams struct {
	// If true, return an error immediately if the VM is still booting. Default: false
	SkipWaitBoot param.Field[bool] `query:"skip_wait_boot"`
}

func (VmDeleteParams) URLQuery 

func (r VmDeleteParams) URLQuery() (v url.Values)

URLQuery serializes VmDeleteParams's query parameters as `url.Values`.

type VmDeleteResponse 

type VmDeleteResponse struct {
	VmID string               `json:"vm_id" api:"required"`
	JSON vmDeleteResponseJSON `json:"-"`
}

Response body for DELETE /api/vm/{vm_id}

func (*VmDeleteResponse) UnmarshalJSON 

func (r *VmDeleteResponse) UnmarshalJSON(data []byte) (err error)

type VmFromCommitRequestCommitIDParam 

type VmFromCommitRequestCommitIDParam struct {
	// The commit ID to restore from
	CommitID param.Field[string] `json:"commit_id" api:"required" format:"uuid"`
}

The commit ID to restore from

func (VmFromCommitRequestCommitIDParam) MarshalJSON 

func (r VmFromCommitRequestCommitIDParam) MarshalJSON() (data []byte, err error)

type VmFromCommitRequestParam 

type VmFromCommitRequestParam struct {
	// The commit ID to restore from
	CommitID param.Field[string] `json:"commit_id" format:"uuid"`
	// A repository reference in "repo_name:tag_name" format
	Ref param.Field[string] `json:"ref"`
	// The tag name to restore from (legacy org-scoped tag)
	TagName param.Field[string] `json:"tag_name"`
}

Request body for POST /api/v1/vm/from_commit

func (VmFromCommitRequestParam) MarshalJSON 

func (r VmFromCommitRequestParam) MarshalJSON() (data []byte, err error)

type VmFromCommitRequestRefParam 

type VmFromCommitRequestRefParam struct {
	// A repository reference in "repo_name:tag_name" format
	Ref param.Field[string] `json:"ref" api:"required"`
}

A repository reference in "repo_name:tag_name" format

func (VmFromCommitRequestRefParam) MarshalJSON 

func (r VmFromCommitRequestRefParam) MarshalJSON() (data []byte, err error)

type VmFromCommitRequestTagNameParam 

type VmFromCommitRequestTagNameParam struct {
	// The tag name to restore from (legacy org-scoped tag)
	TagName param.Field[string] `json:"tag_name" api:"required"`
}

The tag name to restore from (legacy org-scoped tag)

func (VmFromCommitRequestTagNameParam) MarshalJSON 

func (r VmFromCommitRequestTagNameParam) MarshalJSON() (data []byte, err error)

type VmFromCommitRequestUnionParam 

type VmFromCommitRequestUnionParam interface {
	// contains filtered or unexported methods
}

Request body for POST /api/v1/vm/from_commit

Satisfied by VmFromCommitRequestCommitIDParam, VmFromCommitRequestTagNameParam, VmFromCommitRequestRefParam, VmFromCommitRequestParam.

type VmMetadataResponse 

type VmMetadataResponse struct {
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	IP        string    `json:"ip" api:"required"`
	OwnerID   string    `json:"owner_id" api:"required" format:"uuid"`
	// The state of a VM
	State           VmMetadataResponseState `json:"state" api:"required"`
	VmID            string                  `json:"vm_id" api:"required" format:"uuid"`
	DeletedAt       time.Time               `json:"deleted_at" api:"nullable" format:"date-time"`
	GrandparentVmID string                  `json:"grandparent_vm_id" api:"nullable" format:"uuid"`
	ParentCommitID  string                  `json:"parent_commit_id" api:"nullable" format:"uuid"`
	JSON            vmMetadataResponseJSON  `json:"-"`
}

Response for GET /api/v1/vm/{vm_id}/metadata

func (*VmMetadataResponse) UnmarshalJSON 

func (r *VmMetadataResponse) UnmarshalJSON(data []byte) (err error)

type VmMetadataResponseState 

type VmMetadataResponseState string

The state of a VM 

const (
	VmMetadataResponseStateBooting  VmMetadataResponseState = "booting"
	VmMetadataResponseStateRunning  VmMetadataResponseState = "running"
	VmMetadataResponseStatePaused   VmMetadataResponseState = "paused"
	VmMetadataResponseStateSleeping VmMetadataResponseState = "sleeping"
	VmMetadataResponseStateDead     VmMetadataResponseState = "dead"
)

func (VmMetadataResponseState) IsKnown 

func (r VmMetadataResponseState) IsKnown() bool

type VmNewRootParams 

type VmNewRootParams struct {
	NewRootRequest NewRootRequestParam `json:"new_root_request" api:"required"`
	// If true, wait for the newly-created VM to finish booting before returning.
	// Default: false.
	WaitBoot param.Field[bool] `query:"wait_boot"`
}

func (VmNewRootParams) MarshalJSON 

func (r VmNewRootParams) MarshalJSON() (data []byte, err error)

func (VmNewRootParams) URLQuery 

func (r VmNewRootParams) URLQuery() (v url.Values)

URLQuery serializes VmNewRootParams's query parameters as `url.Values`.

type VmResizeDiskParams 

type VmResizeDiskParams struct {
	// Request body for PATCH /api/vm/{vm_id}/disk
	VmResizeDiskRequest VmResizeDiskRequestParam `json:"vm_resize_disk_request" api:"required"`
	// If true, return an error immediately if the VM is still booting. Default: false
	SkipWaitBoot param.Field[bool] `query:"skip_wait_boot"`
}

func (VmResizeDiskParams) MarshalJSON 

func (r VmResizeDiskParams) MarshalJSON() (data []byte, err error)

func (VmResizeDiskParams) URLQuery 

func (r VmResizeDiskParams) URLQuery() (v url.Values)

URLQuery serializes VmResizeDiskParams's query parameters as `url.Values`.

type VmResizeDiskRequestParam 

type VmResizeDiskRequestParam struct {
	// The new disk size in MiB. Must be strictly greater than the current size.
	FsSizeMib param.Field[int64] `json:"fs_size_mib" api:"required"`
}

Request body for PATCH /api/vm/{vm_id}/disk

func (VmResizeDiskRequestParam) MarshalJSON 

func (r VmResizeDiskRequestParam) MarshalJSON() (data []byte, err error)

type VmRestoreFromCommitParams 

type VmRestoreFromCommitParams struct {
	// Request body for POST /api/v1/vm/from_commit
	VmFromCommitRequest VmFromCommitRequestUnionParam `json:"vm_from_commit_request" api:"required"`
}

func (VmRestoreFromCommitParams) MarshalJSON 

func (r VmRestoreFromCommitParams) MarshalJSON() (data []byte, err error)

type VmSSHKeyResponse 

type VmSSHKeyResponse struct {
	// The SSH port that will be DNAT'd to the VM's netns (and, in turn, to its TAP
	// device)
	SSHPort int64 `json:"ssh_port" api:"required"`
	// Private SSH key in stringified OpenSSH format
	SSHPrivateKey string               `json:"ssh_private_key" api:"required"`
	JSON          vmSSHKeyResponseJSON `json:"-"`
}

Response body for GET /api/vm/{vm_id}/ssh_key

func (*VmSSHKeyResponse) UnmarshalJSON 

func (r *VmSSHKeyResponse) UnmarshalJSON(data []byte) (err error)

type VmService 

type VmService struct {
	Options []option.RequestOption
}

VmService contains methods and other services that help with interacting with the vers API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewVmService method instead.

func NewVmService 

func NewVmService(opts ...option.RequestOption) (r *VmService)

NewVmService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*VmService) Branch 

func (r *VmService) Branch(ctx context.Context, vmOrCommitID string, body VmBranchParams, opts ...option.RequestOption) (res *NewVmsResponse, err error)

func (*VmService) BranchByCommit 

func (r *VmService) BranchByCommit(ctx context.Context, commitID string, body VmBranchByCommitParams, opts ...option.RequestOption) (res *NewVmsResponse, err error)

func (*VmService) BranchByTag 

func (r *VmService) BranchByTag(ctx context.Context, tagName string, body VmBranchByTagParams, opts ...option.RequestOption) (res *NewVmsResponse, err error)

func (*VmService) BranchByVm 

func (r *VmService) BranchByVm(ctx context.Context, vmID string, body VmBranchByVmParams, opts ...option.RequestOption) (res *NewVmsResponse, err error)

func (*VmService) Commit 

func (r *VmService) Commit(ctx context.Context, vmID string, body VmCommitParams, opts ...option.RequestOption) (res *VmCommitResponse, err error)

func (*VmService) Delete 

func (r *VmService) Delete(ctx context.Context, vmID string, body VmDeleteParams, opts ...option.RequestOption) (res *VmDeleteResponse, err error)

func (*VmService) GetMetadata 

func (r *VmService) GetMetadata(ctx context.Context, vmID string, opts ...option.RequestOption) (res *VmMetadataResponse, err error)

func (*VmService) GetSSHKey 

func (r *VmService) GetSSHKey(ctx context.Context, vmID string, opts ...option.RequestOption) (res *VmSSHKeyResponse, err error)

func (*VmService) List 

func (r *VmService) List(ctx context.Context, opts ...option.RequestOption) (res *[]Vm, err error)

func (*VmService) NewRoot 

func (r *VmService) NewRoot(ctx context.Context, params VmNewRootParams, opts ...option.RequestOption) (res *NewVmResponse, err error)

func (*VmService) ResizeDisk 

func (r *VmService) ResizeDisk(ctx context.Context, vmID string, params VmResizeDiskParams, opts ...option.RequestOption) (err error)

func (*VmService) RestoreFromCommit 

func (r *VmService) RestoreFromCommit(ctx context.Context, body VmRestoreFromCommitParams, opts ...option.RequestOption) (res *NewVmResponse, err error)

func (*VmService) Status 

func (r *VmService) Status(ctx context.Context, vmID string, opts ...option.RequestOption) (res *Vm, err error)

func (*VmService) UpdateState 

func (r *VmService) UpdateState(ctx context.Context, vmID string, params VmUpdateStateParams, opts ...option.RequestOption) (err error)

type VmState 

type VmState string

The state of a VM 

const (
	VmStateBooting  VmState = "booting"
	VmStateRunning  VmState = "running"
	VmStatePaused   VmState = "paused"
	VmStateSleeping VmState = "sleeping"
	VmStateDead     VmState = "dead"
)

func (VmState) IsKnown 

func (r VmState) IsKnown() bool

type VmUpdateStateParams 

type VmUpdateStateParams struct {
	// Request body for PATCH /api/vm/{vm_id}/state
	VmUpdateStateRequest VmUpdateStateRequestParam `json:"vm_update_state_request" api:"required"`
	// If true, error immediately if the VM is not finished booting. Defaults to false
	SkipWaitBoot param.Field[bool] `query:"skip_wait_boot"`
}

func (VmUpdateStateParams) MarshalJSON 

func (r VmUpdateStateParams) MarshalJSON() (data []byte, err error)

func (VmUpdateStateParams) URLQuery 

func (r VmUpdateStateParams) URLQuery() (v url.Values)

URLQuery serializes VmUpdateStateParams's query parameters as `url.Values`.

type VmUpdateStateRequestParam 

type VmUpdateStateRequestParam struct {
	// The requested state for the VM
	State param.Field[VmUpdateStateRequestState] `json:"state" api:"required"`
}

Request body for PATCH /api/vm/{vm_id}/state

func (VmUpdateStateRequestParam) MarshalJSON 

func (r VmUpdateStateRequestParam) MarshalJSON() (data []byte, err error)

type VmUpdateStateRequestState 

type VmUpdateStateRequestState string

The requested state for the VM 

const (
	VmUpdateStateRequestStatePaused  VmUpdateStateRequestState = "Paused"
	VmUpdateStateRequestStateRunning VmUpdateStateRequestState = "Running"
)

func (VmUpdateStateRequestState) IsKnown 

func (r VmUpdateStateRequestState) IsKnown() bool

Source Files

View all Source files

Directories

Path Synopsis
apierror
apiform
apijson
apiquery
param
requestconfig
testutil

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.