opencode

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: May 16, 2026 License: Apache-2.0 Imports: 20 Imported by: 0

README

Opencode Stainless Go API Library

Go Reference

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

It is generated with Stainless.

Installation

import (
	"github.com/Acksell/opencode-go-sdk" // imported as opencode
)

Or to pin the version:

go get -u 'github.com/Acksell/opencode-go-sdk@v0.1.0'

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/Acksell/opencode-go-sdk"
	"github.com/Acksell/opencode-go-sdk/option"
)

func main() {
	client := opencode.NewClient(
		option.WithAPIKey("My API Key"), // defaults to os.LookupEnv("OPENCODE_STAINLESS_API_KEY")
	)
	response, err := client.Auth.SetCredentials(
		context.TODO(),
		"REPLACE_ME",
		opencode.AuthSetCredentialsParams{},
	)
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", response)
}
Request fields

The opencode library uses the omitzero semantics from the Go 1.24+ encoding/json release for request fields.

Required primitive fields (int64, string, etc.) feature the tag `api:"required"`. These fields are always serialized, even their zero values.

Optional primitive types are wrapped in a param.Opt[T]. These fields can be set with the provided constructors, opencode.String(string), opencode.Int(int64), etc.

Any param.Opt[T], map, slice, struct or string enum uses the tag `json:"...,omitzero"`. Its zero value is considered omitted.

The param.IsOmitted(any) function can confirm the presence of any omitzero field.

p := opencode.ExampleParams{
	ID:   "id_xxx",               // required property
	Name: opencode.String("..."), // optional property

	Point: opencode.Point{
		X: 0,               // required field will serialize as 0
		Y: opencode.Int(1), // optional field will serialize as 1
		// ... omitted non-required fields will not be serialized
	},

	Origin: opencode.Origin{}, // the zero value of [Origin] is considered omitted
}

To send null instead of a param.Opt[T], use param.Null[T](). To send null instead of a struct T, use param.NullStruct[T]().

p.Name = param.Null[string]()       // 'null' instead of string
p.Point = param.NullStruct[Point]() // 'null' instead of struct

param.IsNull(p.Name)  // true
param.IsNull(p.Point) // true

Request structs contain a .SetExtraFields(map[string]any) method which can send non-conforming fields in the request body. Extra fields overwrite any struct fields with a matching key. For security reasons, only use SetExtraFields with trusted data.

To send a custom value instead of a struct, use param.Override[T](value).

// In cases where the API specifies a given type,
// but you want to send something else, use [SetExtraFields]:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// Send a number instead of an object
custom := param.Override[opencode.FooParams](12)
Request unions

Unions are represented as a struct with fields prefixed by "Of" for each of its variants, only one field can be non-zero. The non-zero field will be serialized.

Sub-properties of the union can be accessed via methods on the union struct. These methods return a mutable pointer to the underlying data, if present.

// Only one field can be non-zero, use param.IsOmitted() to check if a field is set
type AnimalUnionParam struct {
	OfCat *Cat `json:",omitzero,inline`
	OfDog *Dog `json:",omitzero,inline`
}

animal := AnimalUnionParam{
	OfCat: &Cat{
		Name: "Whiskers",
		Owner: PersonParam{
			Address: AddressParam{Street: "3333 Coyote Hill Rd", Zip: 0},
		},
	},
}

// Mutating a field
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}
Response objects

All fields in response structs are ordinary value types (not pointers or wrappers). Response structs also include a special JSON field containing metadata about each property.

type Animal struct {
	Name   string `json:"name,nullable"`
	Owners int    `json:"owners"`
	Age    int    `json:"age"`
	JSON   struct {
		Name        respjson.Field
		Owner       respjson.Field
		Age         respjson.Field
		ExtraFields map[string]respjson.Field
	} `json:"-"`
}

To handle optional data, use the .Valid() method on the JSON field. .Valid() returns true if a field is not null, not present, or couldn't be marshaled.

If .Valid() is false, the corresponding field will simply be its zero value.

raw := `{"owners": 1, "name": null}`

var res Animal
json.Unmarshal([]byte(raw), &res)

// Accessing regular fields

res.Owners // 1
res.Name   // ""
res.Age    // 0

// Optional field checks

res.JSON.Owners.Valid() // true
res.JSON.Name.Valid()   // false
res.JSON.Age.Valid()    // false

// Raw JSON values

res.JSON.Owners.Raw()                  // "1"
res.JSON.Name.Raw() == "null"          // true
res.JSON.Name.Raw() == respjson.Null   // true
res.JSON.Age.Raw() == ""               // true
res.JSON.Age.Raw() == respjson.Omitted // true

These .JSON structs also include an ExtraFields 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()
Response Unions

In responses, unions are represented by a flattened struct containing all possible fields from each of the object variants. To convert it to a variant use the .AsFooVariant() method or the .AsAny() method if present.

If a response value union contains primitive values, primitive fields will be alongside the properties but prefixed with Of and feature the tag json:"...,inline".

type AnimalUnion struct {
	// From variants [Dog], [Cat]
	Owner Person `json:"owner"`
	// From variant [Dog]
	DogBreed string `json:"dog_breed"`
	// From variant [Cat]
	CatBreed string `json:"cat_breed"`
	// ...

	JSON struct {
		Owner respjson.Field
		// ...
	} `json:"-"`
}

// If animal variant
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// Switch on the variant
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}
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 := opencode.NewClient(
	// Adds a header to every request made by the client
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Auth.SetCredentials(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"}),
)

The request option option.WithDebugLog(nil) may be helpful while debugging.

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 *opencode.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.Auth.SetCredentials(
	context.TODO(),
	"REPLACE_ME",
	opencode.AuthSetCredentialsParams{},
)
if err != nil {
	var apierr *opencode.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 "/auth/{providerID}": 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.Auth.SetCredentials(
	ctx,
	"REPLACE_ME",
	opencode.AuthSetCredentialsParams{},
	// 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 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 opencode.File(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 := opencode.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Override per-request:
client.Auth.SetCredentials(
	context.TODO(),
	"REPLACE_ME",
	opencode.AuthSetCredentialsParams{},
	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
response, err := client.Auth.SetCredentials(
	context.TODO(),
	"REPLACE_ME",
	opencode.AuthSetCredentialsParams{},
	option.WithResponseInto(&response),
)
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", response)

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]any

    // 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:   "id_xxxx",
    Data: FooNewParamsData{
        FirstName: opencode.String("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 := opencode.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(b bool) param.Opt[bool]

func BoolPtr 

func BoolPtr(v bool) *bool

func DefaultClientOptions 

func DefaultClientOptions() []option.RequestOption

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

func File 

func File(rdr io.Reader, filename string, contentType string) file

func Float 

func Float(f float64) param.Opt[float64]

func FloatPtr 

func FloatPtr(v float64) *float64

func Int 

func Int(i int64) param.Opt[int64]

func IntPtr 

func IntPtr(v int64) *int64

func Opt 

func Opt[T comparable](v T) param.Opt[T]

func Ptr 

func Ptr[T any](v T) *T

func String 

func String(s string) param.Opt[string]

func StringPtr 

func StringPtr(v string) *string

func Time 

func Time(t time.Time) param.Opt[time.Time]

func TimePtr 

func TimePtr(v time.Time) *time.Time

Types

type APIError 

type APIError struct {
	Data APIErrorData `json:"data" api:"required"`
	// Any of "APIError".
	Name APIErrorName `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APIError) RawJSON 

func (r APIError) RawJSON() string

Returns the unmodified JSON received from the API

func (APIError) ToParam 

func (r APIError) ToParam() APIErrorParam

ToParam converts this APIError to a APIErrorParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with APIErrorParam.Overrides()

func (*APIError) UnmarshalJSON 

func (r *APIError) UnmarshalJSON(data []byte) error

type APIErrorData 

type APIErrorData struct {
	IsRetryable     bool              `json:"isRetryable" api:"required"`
	Message         string            `json:"message" api:"required"`
	Metadata        map[string]string `json:"metadata"`
	ResponseBody    string            `json:"responseBody"`
	ResponseHeaders map[string]string `json:"responseHeaders"`
	StatusCode      int64             `json:"statusCode"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		IsRetryable     respjson.Field
		Message         respjson.Field
		Metadata        respjson.Field
		ResponseBody    respjson.Field
		ResponseHeaders respjson.Field
		StatusCode      respjson.Field
		ExtraFields     map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APIErrorData) RawJSON 

func (r APIErrorData) RawJSON() string

Returns the unmodified JSON received from the API

func (*APIErrorData) UnmarshalJSON 

func (r *APIErrorData) UnmarshalJSON(data []byte) error

type APIErrorDataParam 

type APIErrorDataParam struct {
	IsRetryable     bool              `json:"isRetryable" api:"required"`
	Message         string            `json:"message" api:"required"`
	ResponseBody    param.Opt[string] `json:"responseBody,omitzero"`
	StatusCode      param.Opt[int64]  `json:"statusCode,omitzero"`
	Metadata        map[string]string `json:"metadata,omitzero"`
	ResponseHeaders map[string]string `json:"responseHeaders,omitzero"`
	// contains filtered or unexported fields
}

The properties IsRetryable, Message are required.

func (APIErrorDataParam) MarshalJSON 

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

func (*APIErrorDataParam) UnmarshalJSON 

func (r *APIErrorDataParam) UnmarshalJSON(data []byte) error

type APIErrorName 

type APIErrorName string
const (
	APIErrorNameAPIError APIErrorName = "APIError"
)

type APIErrorParam 

type APIErrorParam struct {
	Data APIErrorDataParam `json:"data,omitzero" api:"required"`
	// Any of "APIError".
	Name APIErrorName `json:"name,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Data, Name are required.

func (APIErrorParam) MarshalJSON 

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

func (*APIErrorParam) UnmarshalJSON 

func (r *APIErrorParam) UnmarshalJSON(data []byte) error

type APIModelListParams 

type APIModelListParams struct {
	Location APIModelListParamsLocation `query:"location,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APIModelListParams) URLQuery 

func (r APIModelListParams) URLQuery() (v url.Values, err error)

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

type APIModelListParamsLocation 

type APIModelListParamsLocation struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APIModelListParamsLocation) URLQuery 

func (r APIModelListParamsLocation) URLQuery() (v url.Values, err error)

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

type APIModelService 

type APIModelService struct {
	// contains filtered or unexported fields
}

Experimental v2 model routes.

APIModelService contains methods and other services that help with interacting with the opencode-stainless 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 NewAPIModelService method instead.

func NewAPIModelService 

func NewAPIModelService(opts ...option.RequestOption) (r APIModelService)

NewAPIModelService 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 (*APIModelService) List 

func (r *APIModelService) List(ctx context.Context, query APIModelListParams, opts ...option.RequestOption) (res *[]ModelV2Info, err error)

Retrieve available v2 models ordered by release date.

type APIProviderGetParams 

type APIProviderGetParams struct {
	Location APIProviderGetParamsLocation `query:"location,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APIProviderGetParams) URLQuery 

func (r APIProviderGetParams) URLQuery() (v url.Values, err error)

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

type APIProviderGetParamsLocation 

type APIProviderGetParamsLocation struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APIProviderGetParamsLocation) URLQuery 

func (r APIProviderGetParamsLocation) URLQuery() (v url.Values, err error)

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

type APIProviderListParams 

type APIProviderListParams struct {
	Location APIProviderListParamsLocation `query:"location,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APIProviderListParams) URLQuery 

func (r APIProviderListParams) URLQuery() (v url.Values, err error)

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

type APIProviderListParamsLocation 

type APIProviderListParamsLocation struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APIProviderListParamsLocation) URLQuery 

func (r APIProviderListParamsLocation) URLQuery() (v url.Values, err error)

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

type APIProviderService 

type APIProviderService struct {
	// contains filtered or unexported fields
}

Experimental v2 provider routes.

APIProviderService contains methods and other services that help with interacting with the opencode-stainless 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 NewAPIProviderService method instead.

func NewAPIProviderService 

func NewAPIProviderService(opts ...option.RequestOption) (r APIProviderService)

NewAPIProviderService 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 (*APIProviderService) Get 

func (r *APIProviderService) Get(ctx context.Context, providerID string, query APIProviderGetParams, opts ...option.RequestOption) (res *ProviderV2Info, err error)

Retrieve a single v2 AI provider so clients can inspect its availability and endpoint settings.

func (*APIProviderService) List 

func (r *APIProviderService) List(ctx context.Context, query APIProviderListParams, opts ...option.RequestOption) (res *[]ProviderV2Info, err error)

Retrieve active v2 AI providers so clients can show provider availability and configuration.

type APIService 

type APIService struct {
	Session APISessionService
	// Experimental v2 model routes.
	Model APIModelService
	// Experimental v2 provider routes.
	Provider APIProviderService
	// contains filtered or unexported fields
}

APIService contains methods and other services that help with interacting with the opencode-stainless 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 NewAPIService method instead.

func NewAPIService 

func NewAPIService(opts ...option.RequestOption) (r APIService)

NewAPIService 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.

type APISessionCompactParams 

type APISessionCompactParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APISessionCompactParams) URLQuery 

func (r APISessionCompactParams) URLQuery() (v url.Values, err error)

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

type APISessionGetContextParams 

type APISessionGetContextParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APISessionGetContextParams) URLQuery 

func (r APISessionGetContextParams) URLQuery() (v url.Values, err error)

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

type APISessionGetMessagesParams 

type APISessionGetMessagesParams struct {
	// Opaque pagination cursor returned as cursor.previous or cursor.next in the
	// previous response. Do not combine with order.
	Cursor    param.Opt[string]  `query:"cursor,omitzero" json:"-"`
	Directory param.Opt[string]  `query:"directory,omitzero" json:"-"`
	Limit     param.Opt[float64] `query:"limit,omitzero" json:"-"`
	Workspace param.Opt[string]  `query:"workspace,omitzero" json:"-"`
	// Any of "asc", "desc".
	Order APISessionGetMessagesParamsOrder `query:"order,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APISessionGetMessagesParams) URLQuery 

func (r APISessionGetMessagesParams) URLQuery() (v url.Values, err error)

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

type APISessionGetMessagesParamsOrder 

type APISessionGetMessagesParamsOrder string
const (
	APISessionGetMessagesParamsOrderAsc  APISessionGetMessagesParamsOrder = "asc"
	APISessionGetMessagesParamsOrderDesc APISessionGetMessagesParamsOrder = "desc"
)

type APISessionGetMessagesResponse 

type APISessionGetMessagesResponse struct {
	Cursor APISessionGetMessagesResponseCursor `json:"cursor" api:"required"`
	Items  []SessionMessageUnion               `json:"items" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cursor      respjson.Field
		Items       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionGetMessagesResponse) RawJSON 

func (r APISessionGetMessagesResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionGetMessagesResponse) UnmarshalJSON 

func (r *APISessionGetMessagesResponse) UnmarshalJSON(data []byte) error

type APISessionGetMessagesResponseCursor 

type APISessionGetMessagesResponseCursor struct {
	Next     string `json:"next"`
	Previous string `json:"previous"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Next        respjson.Field
		Previous    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionGetMessagesResponseCursor) RawJSON 

func (r APISessionGetMessagesResponseCursor) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionGetMessagesResponseCursor) UnmarshalJSON 

func (r *APISessionGetMessagesResponseCursor) UnmarshalJSON(data []byte) error

type APISessionListParams 

type APISessionListParams struct {
	// Opaque pagination cursor returned as cursor.previous or cursor.next in the
	// previous response. Do not combine with order or filters.
	Cursor    param.Opt[string]  `query:"cursor,omitzero" json:"-"`
	Directory param.Opt[string]  `query:"directory,omitzero" json:"-"`
	Limit     param.Opt[float64] `query:"limit,omitzero" json:"-"`
	Path      param.Opt[string]  `query:"path,omitzero" json:"-"`
	Search    param.Opt[string]  `query:"search,omitzero" json:"-"`
	Start     param.Opt[float64] `query:"start,omitzero" json:"-"`
	Workspace param.Opt[string]  `query:"workspace,omitzero" json:"-"`
	// Any of "asc", "desc".
	Order APISessionListParamsOrder      `query:"order,omitzero" json:"-"`
	Roots APISessionListParamsRootsUnion `query:"roots,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APISessionListParams) URLQuery 

func (r APISessionListParams) URLQuery() (v url.Values, err error)

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

type APISessionListParamsOrder 

type APISessionListParamsOrder string
const (
	APISessionListParamsOrderAsc  APISessionListParamsOrder = "asc"
	APISessionListParamsOrderDesc APISessionListParamsOrder = "desc"
)

type APISessionListParamsRootsString 

type APISessionListParamsRootsString string
const (
	APISessionListParamsRootsStringTrue  APISessionListParamsRootsString = "true"
	APISessionListParamsRootsStringFalse APISessionListParamsRootsString = "false"
)

type APISessionListParamsRootsUnion 

type APISessionListParamsRootsUnion struct {
	OfBool param.Opt[bool] `query:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfAPISessionListsRootsString)
	OfAPISessionListsRootsString param.Opt[string] `query:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

type APISessionListResponse 

type APISessionListResponse struct {
	Cursor APISessionListResponseCursor `json:"cursor" api:"required"`
	Items  []APISessionListResponseItem `json:"items" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cursor      respjson.Field
		Items       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionListResponse) RawJSON 

func (r APISessionListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionListResponse) UnmarshalJSON 

func (r *APISessionListResponse) UnmarshalJSON(data []byte) error

type APISessionListResponseCursor 

type APISessionListResponseCursor struct {
	Next     string `json:"next"`
	Previous string `json:"previous"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Next        respjson.Field
		Previous    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionListResponseCursor) RawJSON 

func (r APISessionListResponseCursor) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionListResponseCursor) UnmarshalJSON 

func (r *APISessionListResponseCursor) UnmarshalJSON(data []byte) error

type APISessionListResponseItem 

type APISessionListResponseItem struct {
	ID          string                           `json:"id" api:"required"`
	Cost        float64                          `json:"cost" api:"required"`
	ProjectID   string                           `json:"projectID" api:"required"`
	Time        APISessionListResponseItemTime   `json:"time" api:"required"`
	Title       string                           `json:"title" api:"required"`
	Tokens      APISessionListResponseItemTokens `json:"tokens" api:"required"`
	Agent       string                           `json:"agent"`
	Model       APISessionListResponseItemModel  `json:"model"`
	ParentID    string                           `json:"parentID"`
	Path        string                           `json:"path"`
	WorkspaceID string                           `json:"workspaceID"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Cost        respjson.Field
		ProjectID   respjson.Field
		Time        respjson.Field
		Title       respjson.Field
		Tokens      respjson.Field
		Agent       respjson.Field
		Model       respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		WorkspaceID respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionListResponseItem) RawJSON 

func (r APISessionListResponseItem) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionListResponseItem) UnmarshalJSON 

func (r *APISessionListResponseItem) UnmarshalJSON(data []byte) error

type APISessionListResponseItemModel 

type APISessionListResponseItemModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionListResponseItemModel) RawJSON 

func (r APISessionListResponseItemModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionListResponseItemModel) UnmarshalJSON 

func (r *APISessionListResponseItemModel) UnmarshalJSON(data []byte) error

type APISessionListResponseItemTime 

type APISessionListResponseItemTime struct {
	Created  float64 `json:"created" api:"required"`
	Updated  float64 `json:"updated" api:"required"`
	Archived float64 `json:"archived"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Updated     respjson.Field
		Archived    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionListResponseItemTime) RawJSON 

func (r APISessionListResponseItemTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionListResponseItemTime) UnmarshalJSON 

func (r *APISessionListResponseItemTime) UnmarshalJSON(data []byte) error

type APISessionListResponseItemTokens 

type APISessionListResponseItemTokens struct {
	Cache     APISessionListResponseItemTokensCache `json:"cache" api:"required"`
	Input     float64                               `json:"input" api:"required"`
	Output    float64                               `json:"output" api:"required"`
	Reasoning float64                               `json:"reasoning" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionListResponseItemTokens) RawJSON 

func (r APISessionListResponseItemTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionListResponseItemTokens) UnmarshalJSON 

func (r *APISessionListResponseItemTokens) UnmarshalJSON(data []byte) error

type APISessionListResponseItemTokensCache 

type APISessionListResponseItemTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (APISessionListResponseItemTokensCache) RawJSON 

func (r APISessionListResponseItemTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*APISessionListResponseItemTokensCache) UnmarshalJSON 

func (r *APISessionListResponseItemTokensCache) UnmarshalJSON(data []byte) error

type APISessionSendMessageParams 

type APISessionSendMessageParams struct {
	Prompt    PromptParam       `json:"prompt,omitzero" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// Any of "immediate", "deferred".
	Delivery APISessionSendMessageParamsDelivery `json:"delivery,omitzero"`
	// contains filtered or unexported fields
}

func (APISessionSendMessageParams) MarshalJSON 

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

func (APISessionSendMessageParams) URLQuery 

func (r APISessionSendMessageParams) URLQuery() (v url.Values, err error)

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

func (*APISessionSendMessageParams) UnmarshalJSON 

func (r *APISessionSendMessageParams) UnmarshalJSON(data []byte) error

type APISessionSendMessageParamsDelivery 

type APISessionSendMessageParamsDelivery string
const (
	APISessionSendMessageParamsDeliveryImmediate APISessionSendMessageParamsDelivery = "immediate"
	APISessionSendMessageParamsDeliveryDeferred  APISessionSendMessageParamsDelivery = "deferred"
)

type APISessionService 

type APISessionService struct {
	// contains filtered or unexported fields
}

APISessionService contains methods and other services that help with interacting with the opencode-stainless 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 NewAPISessionService method instead.

func NewAPISessionService 

func NewAPISessionService(opts ...option.RequestOption) (r APISessionService)

NewAPISessionService 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 (*APISessionService) Compact 

func (r *APISessionService) Compact(ctx context.Context, sessionID string, body APISessionCompactParams, opts ...option.RequestOption) (err error)

Compact a v2 session conversation.

func (*APISessionService) GetContext 

func (r *APISessionService) GetContext(ctx context.Context, sessionID string, query APISessionGetContextParams, opts ...option.RequestOption) (res *[]SessionMessageUnion, err error)

Retrieve the active context messages for a v2 session (all messages after the last compaction).

func (*APISessionService) GetMessages 

func (r *APISessionService) GetMessages(ctx context.Context, sessionID string, query APISessionGetMessagesParams, opts ...option.RequestOption) (res *APISessionGetMessagesResponse, err error)

Retrieve projected v2 messages for a session. Items keep the requested order across pages; use cursor.next or cursor.previous to move through the ordered timeline.

func (*APISessionService) List 

func (r *APISessionService) List(ctx context.Context, query APISessionListParams, opts ...option.RequestOption) (res *APISessionListResponse, err error)

Retrieve sessions in the requested order. Items keep that order across pages; use cursor.next or cursor.previous to move through the ordered list.

func (*APISessionService) SendMessage 

func (r *APISessionService) SendMessage(ctx context.Context, sessionID string, params APISessionSendMessageParams, opts ...option.RequestOption) (res *SessionMessageUnion, err error)

Create a v2 session message and queue it for the agent loop.

func (*APISessionService) Wait 

func (r *APISessionService) Wait(ctx context.Context, sessionID string, body APISessionWaitParams, opts ...option.RequestOption) (err error)

Wait for a v2 session agent loop to become idle.

type APISessionWaitParams 

type APISessionWaitParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (APISessionWaitParams) URLQuery 

func (r APISessionWaitParams) URLQuery() (v url.Values, err error)

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

type AgentConfig 

type AgentConfig struct {
	// Hex color code (e.g., #FF5733) or theme color (e.g., primary)
	Color       AgentConfigColor `json:"color"`
	Description string           `json:"description"`
	Disable     bool             `json:"disable"`
	Hidden      bool             `json:"hidden"`
	MaxSteps    int64            `json:"maxSteps"`
	// Any of "subagent", "primary", "all".
	Mode        AgentConfigMode       `json:"mode"`
	Model       string                `json:"model"`
	Options     map[string]any        `json:"options"`
	Permission  PermissionConfigUnion `json:"permission"`
	Prompt      string                `json:"prompt"`
	Steps       int64                 `json:"steps"`
	Temperature float64               `json:"temperature"`
	Tools       map[string]bool       `json:"tools"`
	TopP        float64               `json:"top_p"`
	Variant     string                `json:"variant"`
	ExtraFields map[string]any        `json:"" api:"extrafields"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Color       respjson.Field
		Description respjson.Field
		Disable     respjson.Field
		Hidden      respjson.Field
		MaxSteps    respjson.Field
		Mode        respjson.Field
		Model       respjson.Field
		Options     respjson.Field
		Permission  respjson.Field
		Prompt      respjson.Field
		Steps       respjson.Field
		Temperature respjson.Field
		Tools       respjson.Field
		TopP        respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AgentConfig) RawJSON 

func (r AgentConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (AgentConfig) ToParam 

func (r AgentConfig) ToParam() AgentConfigParam

ToParam converts this AgentConfig to a AgentConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with AgentConfigParam.Overrides()

func (*AgentConfig) UnmarshalJSON 

func (r *AgentConfig) UnmarshalJSON(data []byte) error

type AgentConfigColor 

type AgentConfigColor string

Hex color code (e.g., #FF5733) or theme color (e.g., primary) 

const (
	AgentConfigColorPrimary   AgentConfigColor = "primary"
	AgentConfigColorSecondary AgentConfigColor = "secondary"
	AgentConfigColorAccent    AgentConfigColor = "accent"
	AgentConfigColorSuccess   AgentConfigColor = "success"
	AgentConfigColorWarning   AgentConfigColor = "warning"
	AgentConfigColorError     AgentConfigColor = "error"
	AgentConfigColorInfo      AgentConfigColor = "info"
)

type AgentConfigMode 

type AgentConfigMode string
const (
	AgentConfigModeSubagent AgentConfigMode = "subagent"
	AgentConfigModePrimary  AgentConfigMode = "primary"
	AgentConfigModeAll      AgentConfigMode = "all"
)

type AgentConfigParam 

type AgentConfigParam struct {
	Description param.Opt[string]  `json:"description,omitzero"`
	Disable     param.Opt[bool]    `json:"disable,omitzero"`
	Hidden      param.Opt[bool]    `json:"hidden,omitzero"`
	MaxSteps    param.Opt[int64]   `json:"maxSteps,omitzero"`
	Model       param.Opt[string]  `json:"model,omitzero"`
	Prompt      param.Opt[string]  `json:"prompt,omitzero"`
	Steps       param.Opt[int64]   `json:"steps,omitzero"`
	Temperature param.Opt[float64] `json:"temperature,omitzero"`
	TopP        param.Opt[float64] `json:"top_p,omitzero"`
	Variant     param.Opt[string]  `json:"variant,omitzero"`
	// Hex color code (e.g., #FF5733) or theme color (e.g., primary)
	Color AgentConfigColor `json:"color,omitzero"`
	// Any of "subagent", "primary", "all".
	Mode        AgentConfigMode            `json:"mode,omitzero"`
	Options     map[string]any             `json:"options,omitzero"`
	Permission  PermissionConfigUnionParam `json:"permission,omitzero"`
	Tools       map[string]bool            `json:"tools,omitzero"`
	ExtraFields map[string]any             `json:"-"`
	// contains filtered or unexported fields
}

func (AgentConfigParam) MarshalJSON 

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

func (*AgentConfigParam) UnmarshalJSON 

func (r *AgentConfigParam) UnmarshalJSON(data []byte) error

type AgentListParams 

type AgentListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (AgentListParams) URLQuery 

func (r AgentListParams) URLQuery() (v url.Values, err error)

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

type AgentListResponse 

type AgentListResponse struct {
	// Any of "subagent", "primary", "all".
	Mode        AgentListResponseMode  `json:"mode" api:"required"`
	Name        string                 `json:"name" api:"required"`
	Options     map[string]any         `json:"options" api:"required"`
	Permission  []PermissionRule       `json:"permission" api:"required"`
	Color       string                 `json:"color"`
	Description string                 `json:"description"`
	Hidden      bool                   `json:"hidden"`
	Model       AgentListResponseModel `json:"model"`
	Native      bool                   `json:"native"`
	Prompt      string                 `json:"prompt"`
	Steps       float64                `json:"steps"`
	Temperature float64                `json:"temperature"`
	TopP        float64                `json:"topP"`
	Variant     string                 `json:"variant"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Mode        respjson.Field
		Name        respjson.Field
		Options     respjson.Field
		Permission  respjson.Field
		Color       respjson.Field
		Description respjson.Field
		Hidden      respjson.Field
		Model       respjson.Field
		Native      respjson.Field
		Prompt      respjson.Field
		Steps       respjson.Field
		Temperature respjson.Field
		TopP        respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AgentListResponse) RawJSON 

func (r AgentListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*AgentListResponse) UnmarshalJSON 

func (r *AgentListResponse) UnmarshalJSON(data []byte) error

type AgentListResponseMode 

type AgentListResponseMode string
const (
	AgentListResponseModeSubagent AgentListResponseMode = "subagent"
	AgentListResponseModePrimary  AgentListResponseMode = "primary"
	AgentListResponseModeAll      AgentListResponseMode = "all"
)

type AgentListResponseModel 

type AgentListResponseModel struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ModelID     respjson.Field
		ProviderID  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AgentListResponseModel) RawJSON 

func (r AgentListResponseModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*AgentListResponseModel) UnmarshalJSON 

func (r *AgentListResponseModel) UnmarshalJSON(data []byte) error

type AgentPartInputParam 

type AgentPartInputParam struct {
	Name string `json:"name" api:"required"`
	// Any of "agent".
	Type   AgentPartInputType        `json:"type,omitzero" api:"required"`
	ID     param.Opt[string]         `json:"id,omitzero"`
	Source AgentPartInputSourceParam `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The properties Name, Type are required.

func (AgentPartInputParam) MarshalJSON 

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

func (*AgentPartInputParam) UnmarshalJSON 

func (r *AgentPartInputParam) UnmarshalJSON(data []byte) error

type AgentPartInputSourceParam 

type AgentPartInputSourceParam struct {
	End   int64  `json:"end" api:"required"`
	Start int64  `json:"start" api:"required"`
	Value string `json:"value" api:"required"`
	// contains filtered or unexported fields
}

The properties End, Start, Value are required.

func (AgentPartInputSourceParam) MarshalJSON 

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

func (*AgentPartInputSourceParam) UnmarshalJSON 

func (r *AgentPartInputSourceParam) UnmarshalJSON(data []byte) error

type AgentPartInputType 

type AgentPartInputType string
const (
	AgentPartInputTypeAgent AgentPartInputType = "agent"
)

type AgentService 

type AgentService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

AgentService contains methods and other services that help with interacting with the opencode-stainless 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 NewAgentService method instead.

func NewAgentService 

func NewAgentService(opts ...option.RequestOption) (r AgentService)

NewAgentService 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 (*AgentService) List 

func (r *AgentService) List(ctx context.Context, query AgentListParams, opts ...option.RequestOption) (res *[]AgentListResponse, err error)

Get a list of all available AI agents in the OpenCode system.

type AssistantMessage 

type AssistantMessage struct {
	ID         string               `json:"id" api:"required"`
	Agent      string               `json:"agent" api:"required"`
	Cost       float64              `json:"cost" api:"required"`
	Mode       string               `json:"mode" api:"required"`
	ModelID    string               `json:"modelID" api:"required"`
	ParentID   string               `json:"parentID" api:"required"`
	Path       AssistantMessagePath `json:"path" api:"required"`
	ProviderID string               `json:"providerID" api:"required"`
	// Any of "assistant".
	Role       AssistantMessageRole       `json:"role" api:"required"`
	SessionID  string                     `json:"sessionID" api:"required"`
	Time       AssistantMessageTime       `json:"time" api:"required"`
	Tokens     AssistantMessageTokens     `json:"tokens" api:"required"`
	Error      AssistantMessageErrorUnion `json:"error"`
	Finish     string                     `json:"finish"`
	Structured any                        `json:"structured"`
	Summary    bool                       `json:"summary"`
	Variant    string                     `json:"variant"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Agent       respjson.Field
		Cost        respjson.Field
		Mode        respjson.Field
		ModelID     respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		ProviderID  respjson.Field
		Role        respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		Tokens      respjson.Field
		Error       respjson.Field
		Finish      respjson.Field
		Structured  respjson.Field
		Summary     respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AssistantMessage) RawJSON 

func (r AssistantMessage) RawJSON() string

Returns the unmodified JSON received from the API

func (*AssistantMessage) UnmarshalJSON 

func (r *AssistantMessage) UnmarshalJSON(data []byte) error

type AssistantMessageErrorUnion 

type AssistantMessageErrorUnion struct {
	// This field is a union of [ProviderAuthErrorData], [UnknownErrorData],
	// [map[string]any], [MessageAbortedErrorData], [StructuredOutputErrorData],
	// [ContextOverflowErrorData], [APIErrorData]
	Data AssistantMessageErrorUnionData `json:"data"`
	Name string                         `json:"name"`
	JSON struct {
		Data respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

AssistantMessageErrorUnion contains all possible properties and values from ProviderAuthError, UnknownError, MessageOutputLengthError, MessageAbortedError, StructuredOutputError, ContextOverflowError, APIError.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (AssistantMessageErrorUnion) AsAPIError 

func (u AssistantMessageErrorUnion) AsAPIError() (v APIError)

func (AssistantMessageErrorUnion) AsContextOverflowError 

func (u AssistantMessageErrorUnion) AsContextOverflowError() (v ContextOverflowError)

func (AssistantMessageErrorUnion) AsMessageAbortedError 

func (u AssistantMessageErrorUnion) AsMessageAbortedError() (v MessageAbortedError)

func (AssistantMessageErrorUnion) AsMessageOutputLengthError 

func (u AssistantMessageErrorUnion) AsMessageOutputLengthError() (v MessageOutputLengthError)

func (AssistantMessageErrorUnion) AsProviderAuthError 

func (u AssistantMessageErrorUnion) AsProviderAuthError() (v ProviderAuthError)

func (AssistantMessageErrorUnion) AsStructuredOutputError 

func (u AssistantMessageErrorUnion) AsStructuredOutputError() (v StructuredOutputError)

func (AssistantMessageErrorUnion) AsUnknownError 

func (u AssistantMessageErrorUnion) AsUnknownError() (v UnknownError)

func (AssistantMessageErrorUnion) RawJSON 

func (u AssistantMessageErrorUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*AssistantMessageErrorUnion) UnmarshalJSON 

func (r *AssistantMessageErrorUnion) UnmarshalJSON(data []byte) error

type AssistantMessageErrorUnionData 

type AssistantMessageErrorUnionData struct {
	// This field will be present if the value is a [any] instead of an object.
	OfMessageOutputLengthErrorData any    `json:",inline"`
	Message                        string `json:"message"`
	// This field is from variant [ProviderAuthErrorData].
	ProviderID string `json:"providerID"`
	// This field is from variant [StructuredOutputErrorData].
	Retries      int64  `json:"retries"`
	ResponseBody string `json:"responseBody"`
	// This field is from variant [APIErrorData].
	IsRetryable bool `json:"isRetryable"`
	// This field is from variant [APIErrorData].
	Metadata map[string]string `json:"metadata"`
	// This field is from variant [APIErrorData].
	ResponseHeaders map[string]string `json:"responseHeaders"`
	// This field is from variant [APIErrorData].
	StatusCode int64 `json:"statusCode"`
	JSON       struct {
		OfMessageOutputLengthErrorData respjson.Field
		Message                        respjson.Field
		ProviderID                     respjson.Field
		Retries                        respjson.Field
		ResponseBody                   respjson.Field
		IsRetryable                    respjson.Field
		Metadata                       respjson.Field
		ResponseHeaders                respjson.Field
		StatusCode                     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

AssistantMessageErrorUnionData is an implicit subunion of AssistantMessageErrorUnion. AssistantMessageErrorUnionData provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the AssistantMessageErrorUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfMessageOutputLengthErrorData]

func (*AssistantMessageErrorUnionData) UnmarshalJSON 

func (r *AssistantMessageErrorUnionData) UnmarshalJSON(data []byte) error

type AssistantMessagePath 

type AssistantMessagePath struct {
	Cwd  string `json:"cwd" api:"required"`
	Root string `json:"root" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cwd         respjson.Field
		Root        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AssistantMessagePath) RawJSON 

func (r AssistantMessagePath) RawJSON() string

Returns the unmodified JSON received from the API

func (*AssistantMessagePath) UnmarshalJSON 

func (r *AssistantMessagePath) UnmarshalJSON(data []byte) error

type AssistantMessageRole 

type AssistantMessageRole string
const (
	AssistantMessageRoleAssistant AssistantMessageRole = "assistant"
)

type AssistantMessageTime 

type AssistantMessageTime struct {
	Created   int64 `json:"created" api:"required"`
	Completed int64 `json:"completed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Completed   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AssistantMessageTime) RawJSON 

func (r AssistantMessageTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*AssistantMessageTime) UnmarshalJSON 

func (r *AssistantMessageTime) UnmarshalJSON(data []byte) error

type AssistantMessageTokens 

type AssistantMessageTokens struct {
	Cache     AssistantMessageTokensCache `json:"cache" api:"required"`
	Input     float64                     `json:"input" api:"required"`
	Output    float64                     `json:"output" api:"required"`
	Reasoning float64                     `json:"reasoning" api:"required"`
	Total     float64                     `json:"total"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		Total       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AssistantMessageTokens) RawJSON 

func (r AssistantMessageTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*AssistantMessageTokens) UnmarshalJSON 

func (r *AssistantMessageTokens) UnmarshalJSON(data []byte) error

type AssistantMessageTokensCache 

type AssistantMessageTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (AssistantMessageTokensCache) RawJSON 

func (r AssistantMessageTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*AssistantMessageTokensCache) UnmarshalJSON 

func (r *AssistantMessageTokensCache) UnmarshalJSON(data []byte) error

type AuthService 

type AuthService struct {
	// contains filtered or unexported fields
}

Control plane routes.

AuthService contains methods and other services that help with interacting with the opencode-stainless 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 NewAuthService method instead.

func NewAuthService 

func NewAuthService(opts ...option.RequestOption) (r AuthService)

NewAuthService 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 (*AuthService) RemoveCredentials 

func (r *AuthService) RemoveCredentials(ctx context.Context, providerID string, opts ...option.RequestOption) (res *bool, err error)

Remove authentication credentials

func (*AuthService) SetCredentials 

func (r *AuthService) SetCredentials(ctx context.Context, providerID string, body AuthSetCredentialsParams, opts ...option.RequestOption) (res *bool, err error)

Set authentication credentials

type AuthSetCredentialsParams 

type AuthSetCredentialsParams struct {

	// This field is a request body variant, only one variant field can be set.
	OfOAuth *AuthSetCredentialsParamsBodyOAuth `json:",inline"`
	// This field is a request body variant, only one variant field can be set.
	OfAPIAuth *AuthSetCredentialsParamsBodyAPIAuth `json:",inline"`
	// This field is a request body variant, only one variant field can be set.
	OfWellKnownAuth *AuthSetCredentialsParamsBodyWellKnownAuth `json:",inline"`
	// contains filtered or unexported fields
}

func (AuthSetCredentialsParams) MarshalJSON 

func (u AuthSetCredentialsParams) MarshalJSON() ([]byte, error)

func (*AuthSetCredentialsParams) UnmarshalJSON 

func (r *AuthSetCredentialsParams) UnmarshalJSON(data []byte) error

type AuthSetCredentialsParamsBodyAPIAuth 

type AuthSetCredentialsParamsBodyAPIAuth struct {
	Key string `json:"key" api:"required"`
	// Any of "api".
	Type     string            `json:"type,omitzero" api:"required"`
	Metadata map[string]string `json:"metadata,omitzero"`
	// contains filtered or unexported fields
}

The properties Key, Type are required.

func (AuthSetCredentialsParamsBodyAPIAuth) MarshalJSON 

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

func (*AuthSetCredentialsParamsBodyAPIAuth) UnmarshalJSON 

func (r *AuthSetCredentialsParamsBodyAPIAuth) UnmarshalJSON(data []byte) error

type AuthSetCredentialsParamsBodyOAuth 

type AuthSetCredentialsParamsBodyOAuth struct {
	Access  string `json:"access" api:"required"`
	Expires int64  `json:"expires" api:"required"`
	Refresh string `json:"refresh" api:"required"`
	// Any of "oauth".
	Type          string            `json:"type,omitzero" api:"required"`
	AccountID     param.Opt[string] `json:"accountId,omitzero"`
	EnterpriseURL param.Opt[string] `json:"enterpriseUrl,omitzero"`
	// contains filtered or unexported fields
}

The properties Access, Expires, Refresh, Type are required.

func (AuthSetCredentialsParamsBodyOAuth) MarshalJSON 

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

func (*AuthSetCredentialsParamsBodyOAuth) UnmarshalJSON 

func (r *AuthSetCredentialsParamsBodyOAuth) UnmarshalJSON(data []byte) error

type AuthSetCredentialsParamsBodyWellKnownAuth 

type AuthSetCredentialsParamsBodyWellKnownAuth struct {
	Token string `json:"token" api:"required"`
	Key   string `json:"key" api:"required"`
	// Any of "wellknown".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Token, Key, Type are required.

func (AuthSetCredentialsParamsBodyWellKnownAuth) MarshalJSON 

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

func (*AuthSetCredentialsParamsBodyWellKnownAuth) UnmarshalJSON 

func (r *AuthSetCredentialsParamsBodyWellKnownAuth) UnmarshalJSON(data []byte) error

type Client 

type Client struct {

	// Control plane routes.
	Auth AuthService
	// Control plane routes.
	Log LogService
	// Global server routes.
	Global GlobalService
	// Instance event stream route.
	Event EventService
	// Experimental HttpApi config routes.
	Config ConfigService
	// Experimental HttpApi read-only routes.
	Experimental ExperimentalService
	// Experimental HttpApi file routes.
	Find FindService
	// Experimental HttpApi file routes.
	File FileService
	// Experimental HttpApi instance read routes.
	Instance InstanceService
	// Experimental HttpApi instance read routes.
	Path PathService
	// Experimental HttpApi instance read routes.
	Vcs VcService
	// Experimental HttpApi instance read routes.
	Command CommandService
	// Experimental HttpApi instance read routes.
	Agent AgentService
	// Experimental HttpApi instance read routes.
	Skill SkillService
	// Experimental HttpApi instance read routes.
	Lsp LspService
	// Experimental HttpApi instance read routes.
	Formatter FormatterService
	// Experimental HttpApi MCP routes.
	Mcp McpService
	// Experimental HttpApi project routes.
	Project ProjectService
	// Experimental HttpApi PTY routes.
	Pty PtyService
	// Question routes.
	Question QuestionService
	// Experimental HttpApi permission routes.
	Permission PermissionService
	// Experimental HttpApi provider routes.
	Provider ProviderService
	// Experimental HttpApi session routes.
	Session SessionService
	// Experimental HttpApi sync routes.
	Sync SyncService
	API  APIService
	// Experimental HttpApi TUI routes.
	Tui TuiService
	// contains filtered or unexported fields
}

Client creates a struct with services and top level methods that help with interacting with the opencode-stainless 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 (OPENCODE_STAINLESS_API_KEY, OPENCODE_STAINLESS_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 any, res any, 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 any, res any, 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 any, res any, 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 any, res any, 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 any, res any, 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 any, res any, 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 CommandListParams 

type CommandListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (CommandListParams) URLQuery 

func (r CommandListParams) URLQuery() (v url.Values, err error)

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

type CommandListResponse 

type CommandListResponse struct {
	Hints       []string `json:"hints" api:"required"`
	Name        string   `json:"name" api:"required"`
	Template    string   `json:"template" api:"required"`
	Agent       string   `json:"agent"`
	Description string   `json:"description"`
	Model       string   `json:"model"`
	// Any of "command", "mcp", "skill".
	Source  CommandListResponseSource `json:"source"`
	Subtask bool                      `json:"subtask"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Hints       respjson.Field
		Name        respjson.Field
		Template    respjson.Field
		Agent       respjson.Field
		Description respjson.Field
		Model       respjson.Field
		Source      respjson.Field
		Subtask     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (CommandListResponse) RawJSON 

func (r CommandListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*CommandListResponse) UnmarshalJSON 

func (r *CommandListResponse) UnmarshalJSON(data []byte) error

type CommandListResponseSource 

type CommandListResponseSource string
const (
	CommandListResponseSourceCommand CommandListResponseSource = "command"
	CommandListResponseSourceMcp     CommandListResponseSource = "mcp"
	CommandListResponseSourceSkill   CommandListResponseSource = "skill"
)

type CommandService 

type CommandService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

CommandService contains methods and other services that help with interacting with the opencode-stainless 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 NewCommandService method instead.

func NewCommandService 

func NewCommandService(opts ...option.RequestOption) (r CommandService)

NewCommandService 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 (*CommandService) List 

func (r *CommandService) List(ctx context.Context, query CommandListParams, opts ...option.RequestOption) (res *[]CommandListResponse, err error)

Get a list of all available commands in the OpenCode system.

type Config 

type Config struct {
	Schema     string           `json:"$schema"`
	Agent      ConfigAgent      `json:"agent"`
	Attachment ConfigAttachment `json:"attachment"`
	Autoshare  bool             `json:"autoshare"`
	// Automatically update to the latest version. Set to true to auto-update, false to
	// disable, or 'notify' to show update notifications
	Autoupdate        ConfigAutoupdateUnion    `json:"autoupdate"`
	Command           map[string]ConfigCommand `json:"command"`
	Compaction        ConfigCompaction         `json:"compaction"`
	DefaultAgent      string                   `json:"default_agent"`
	DisabledProviders []string                 `json:"disabled_providers"`
	EnabledProviders  []string                 `json:"enabled_providers"`
	Enterprise        ConfigEnterprise         `json:"enterprise"`
	Experimental      ConfigExperimental       `json:"experimental"`
	// Enable or configure formatters. Omit or set to false to disable, true to enable
	// built-ins, or an object to enable built-ins with overrides.
	Formatter    ConfigFormatterUnion `json:"formatter"`
	Instructions []string             `json:"instructions"`
	// @deprecated Always uses stretch layout.
	//
	// Any of "auto", "stretch".
	Layout ConfigLayout `json:"layout"`
	// Log level
	//
	// Any of "DEBUG", "INFO", "WARN", "ERROR".
	LogLevel ConfigLogLevel `json:"logLevel"`
	// Enable or configure LSP servers. Omit or set to false to disable, true to enable
	// built-ins, or an object to enable built-ins with overrides.
	Lsp        ConfigLspUnion                  `json:"lsp"`
	Mcp        map[string]ConfigMcpUnion       `json:"mcp"`
	Mode       ConfigMode                      `json:"mode"`
	Model      string                          `json:"model"`
	Permission PermissionConfigUnion           `json:"permission"`
	Plugin     []ConfigPluginUnion             `json:"plugin"`
	Provider   map[string]ConfigProvider       `json:"provider"`
	Reference  map[string]ConfigReferenceUnion `json:"reference"`
	// Server configuration for opencode serve and web commands
	Server ConfigServer `json:"server"`
	// Any of "manual", "auto", "disabled".
	Share      ConfigShare      `json:"share"`
	Shell      string           `json:"shell"`
	Skills     ConfigSkills     `json:"skills"`
	SmallModel string           `json:"small_model"`
	Snapshot   bool             `json:"snapshot"`
	ToolOutput ConfigToolOutput `json:"tool_output"`
	Tools      map[string]bool  `json:"tools"`
	Username   string           `json:"username"`
	Watcher    ConfigWatcher    `json:"watcher"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Schema            respjson.Field
		Agent             respjson.Field
		Attachment        respjson.Field
		Autoshare         respjson.Field
		Autoupdate        respjson.Field
		Command           respjson.Field
		Compaction        respjson.Field
		DefaultAgent      respjson.Field
		DisabledProviders respjson.Field
		EnabledProviders  respjson.Field
		Enterprise        respjson.Field
		Experimental      respjson.Field
		Formatter         respjson.Field
		Instructions      respjson.Field
		Layout            respjson.Field
		LogLevel          respjson.Field
		Lsp               respjson.Field
		Mcp               respjson.Field
		Mode              respjson.Field
		Model             respjson.Field
		Permission        respjson.Field
		Plugin            respjson.Field
		Provider          respjson.Field
		Reference         respjson.Field
		Server            respjson.Field
		Share             respjson.Field
		Shell             respjson.Field
		Skills            respjson.Field
		SmallModel        respjson.Field
		Snapshot          respjson.Field
		ToolOutput        respjson.Field
		Tools             respjson.Field
		Username          respjson.Field
		Watcher           respjson.Field
		ExtraFields       map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Config) RawJSON 

func (r Config) RawJSON() string

Returns the unmodified JSON received from the API

func (Config) ToParam 

func (r Config) ToParam() ConfigParam

ToParam converts this Config to a ConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with ConfigParam.Overrides()

func (*Config) UnmarshalJSON 

func (r *Config) UnmarshalJSON(data []byte) error

type ConfigAgent 

type ConfigAgent struct {
	Build       AgentConfig            `json:"build"`
	Compaction  AgentConfig            `json:"compaction"`
	Explore     AgentConfig            `json:"explore"`
	General     AgentConfig            `json:"general"`
	Plan        AgentConfig            `json:"plan"`
	Scout       AgentConfig            `json:"scout"`
	Summary     AgentConfig            `json:"summary"`
	Title       AgentConfig            `json:"title"`
	ExtraFields map[string]AgentConfig `json:"" api:"extrafields"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Build       respjson.Field
		Compaction  respjson.Field
		Explore     respjson.Field
		General     respjson.Field
		Plan        respjson.Field
		Scout       respjson.Field
		Summary     respjson.Field
		Title       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigAgent) RawJSON 

func (r ConfigAgent) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigAgent) UnmarshalJSON 

func (r *ConfigAgent) UnmarshalJSON(data []byte) error

type ConfigAgentParam 

type ConfigAgentParam struct {
	Build       AgentConfigParam            `json:"build,omitzero"`
	Compaction  AgentConfigParam            `json:"compaction,omitzero"`
	Explore     AgentConfigParam            `json:"explore,omitzero"`
	General     AgentConfigParam            `json:"general,omitzero"`
	Plan        AgentConfigParam            `json:"plan,omitzero"`
	Scout       AgentConfigParam            `json:"scout,omitzero"`
	Summary     AgentConfigParam            `json:"summary,omitzero"`
	Title       AgentConfigParam            `json:"title,omitzero"`
	ExtraFields map[string]AgentConfigParam `json:"-"`
	// contains filtered or unexported fields
}

func (ConfigAgentParam) MarshalJSON 

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

func (*ConfigAgentParam) UnmarshalJSON 

func (r *ConfigAgentParam) UnmarshalJSON(data []byte) error

type ConfigAttachment 

type ConfigAttachment struct {
	Image ConfigAttachmentImage `json:"image"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Image       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigAttachment) RawJSON 

func (r ConfigAttachment) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigAttachment) UnmarshalJSON 

func (r *ConfigAttachment) UnmarshalJSON(data []byte) error

type ConfigAttachmentImage 

type ConfigAttachmentImage struct {
	AutoResize     bool  `json:"auto_resize"`
	MaxBase64Bytes int64 `json:"max_base64_bytes"`
	MaxHeight      int64 `json:"max_height"`
	MaxWidth       int64 `json:"max_width"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AutoResize     respjson.Field
		MaxBase64Bytes respjson.Field
		MaxHeight      respjson.Field
		MaxWidth       respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigAttachmentImage) RawJSON 

func (r ConfigAttachmentImage) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigAttachmentImage) UnmarshalJSON 

func (r *ConfigAttachmentImage) UnmarshalJSON(data []byte) error

type ConfigAttachmentImageParam 

type ConfigAttachmentImageParam struct {
	AutoResize     param.Opt[bool]  `json:"auto_resize,omitzero"`
	MaxBase64Bytes param.Opt[int64] `json:"max_base64_bytes,omitzero"`
	MaxHeight      param.Opt[int64] `json:"max_height,omitzero"`
	MaxWidth       param.Opt[int64] `json:"max_width,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigAttachmentImageParam) MarshalJSON 

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

func (*ConfigAttachmentImageParam) UnmarshalJSON 

func (r *ConfigAttachmentImageParam) UnmarshalJSON(data []byte) error

type ConfigAttachmentParam 

type ConfigAttachmentParam struct {
	Image ConfigAttachmentImageParam `json:"image,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigAttachmentParam) MarshalJSON 

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

func (*ConfigAttachmentParam) UnmarshalJSON 

func (r *ConfigAttachmentParam) UnmarshalJSON(data []byte) error

type ConfigAutoupdateString 

type ConfigAutoupdateString string
const (
	ConfigAutoupdateStringNotify ConfigAutoupdateString = "notify"
)

type ConfigAutoupdateUnion 

type ConfigAutoupdateUnion struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool bool `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfConfigAutoupdateString string `json:",inline"`
	JSON                     struct {
		OfBool                   respjson.Field
		OfConfigAutoupdateString respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigAutoupdateUnion contains all possible properties and values from [bool], [string].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfBool OfConfigAutoupdateString]

func (ConfigAutoupdateUnion) AsBool 

func (u ConfigAutoupdateUnion) AsBool() (v bool)

func (ConfigAutoupdateUnion) AsConfigAutoupdateString 

func (u ConfigAutoupdateUnion) AsConfigAutoupdateString() (v string)

func (ConfigAutoupdateUnion) RawJSON 

func (u ConfigAutoupdateUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigAutoupdateUnion) UnmarshalJSON 

func (r *ConfigAutoupdateUnion) UnmarshalJSON(data []byte) error

type ConfigAutoupdateUnionParam 

type ConfigAutoupdateUnionParam struct {
	OfBool param.Opt[bool] `json:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfConfigAutoupdateString)
	OfConfigAutoupdateString param.Opt[string] `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigAutoupdateUnionParam) MarshalJSON 

func (u ConfigAutoupdateUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigAutoupdateUnionParam) UnmarshalJSON 

func (u *ConfigAutoupdateUnionParam) UnmarshalJSON(data []byte) error

type ConfigCommand 

type ConfigCommand struct {
	Template    string `json:"template" api:"required"`
	Agent       string `json:"agent"`
	Description string `json:"description"`
	Model       string `json:"model"`
	Subtask     bool   `json:"subtask"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Template    respjson.Field
		Agent       respjson.Field
		Description respjson.Field
		Model       respjson.Field
		Subtask     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigCommand) RawJSON 

func (r ConfigCommand) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigCommand) UnmarshalJSON 

func (r *ConfigCommand) UnmarshalJSON(data []byte) error

type ConfigCommandParam 

type ConfigCommandParam struct {
	Template    string            `json:"template" api:"required"`
	Agent       param.Opt[string] `json:"agent,omitzero"`
	Description param.Opt[string] `json:"description,omitzero"`
	Model       param.Opt[string] `json:"model,omitzero"`
	Subtask     param.Opt[bool]   `json:"subtask,omitzero"`
	// contains filtered or unexported fields
}

The property Template is required.

func (ConfigCommandParam) MarshalJSON 

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

func (*ConfigCommandParam) UnmarshalJSON 

func (r *ConfigCommandParam) UnmarshalJSON(data []byte) error

type ConfigCompaction 

type ConfigCompaction struct {
	Auto                 bool  `json:"auto"`
	PreserveRecentTokens int64 `json:"preserve_recent_tokens"`
	Prune                bool  `json:"prune"`
	Reserved             int64 `json:"reserved"`
	TailTurns            int64 `json:"tail_turns"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Auto                 respjson.Field
		PreserveRecentTokens respjson.Field
		Prune                respjson.Field
		Reserved             respjson.Field
		TailTurns            respjson.Field
		ExtraFields          map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigCompaction) RawJSON 

func (r ConfigCompaction) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigCompaction) UnmarshalJSON 

func (r *ConfigCompaction) UnmarshalJSON(data []byte) error

type ConfigCompactionParam 

type ConfigCompactionParam struct {
	Auto                 param.Opt[bool]  `json:"auto,omitzero"`
	PreserveRecentTokens param.Opt[int64] `json:"preserve_recent_tokens,omitzero"`
	Prune                param.Opt[bool]  `json:"prune,omitzero"`
	Reserved             param.Opt[int64] `json:"reserved,omitzero"`
	TailTurns            param.Opt[int64] `json:"tail_turns,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigCompactionParam) MarshalJSON 

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

func (*ConfigCompactionParam) UnmarshalJSON 

func (r *ConfigCompactionParam) UnmarshalJSON(data []byte) error

type ConfigEnterprise 

type ConfigEnterprise struct {
	URL string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigEnterprise) RawJSON 

func (r ConfigEnterprise) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigEnterprise) UnmarshalJSON 

func (r *ConfigEnterprise) UnmarshalJSON(data []byte) error

type ConfigEnterpriseParam 

type ConfigEnterpriseParam struct {
	URL param.Opt[string] `json:"url,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigEnterpriseParam) MarshalJSON 

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

func (*ConfigEnterpriseParam) UnmarshalJSON 

func (r *ConfigEnterpriseParam) UnmarshalJSON(data []byte) error

type ConfigExperimental 

type ConfigExperimental struct {
	BatchTool           bool     `json:"batch_tool"`
	ContinueLoopOnDeny  bool     `json:"continue_loop_on_deny"`
	DisablePasteSummary bool     `json:"disable_paste_summary"`
	McpTimeout          int64    `json:"mcp_timeout"`
	OpenTelemetry       bool     `json:"openTelemetry"`
	PrimaryTools        []string `json:"primary_tools"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		BatchTool           respjson.Field
		ContinueLoopOnDeny  respjson.Field
		DisablePasteSummary respjson.Field
		McpTimeout          respjson.Field
		OpenTelemetry       respjson.Field
		PrimaryTools        respjson.Field
		ExtraFields         map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigExperimental) RawJSON 

func (r ConfigExperimental) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigExperimental) UnmarshalJSON 

func (r *ConfigExperimental) UnmarshalJSON(data []byte) error

type ConfigExperimentalParam 

type ConfigExperimentalParam struct {
	BatchTool           param.Opt[bool]  `json:"batch_tool,omitzero"`
	ContinueLoopOnDeny  param.Opt[bool]  `json:"continue_loop_on_deny,omitzero"`
	DisablePasteSummary param.Opt[bool]  `json:"disable_paste_summary,omitzero"`
	McpTimeout          param.Opt[int64] `json:"mcp_timeout,omitzero"`
	OpenTelemetry       param.Opt[bool]  `json:"openTelemetry,omitzero"`
	PrimaryTools        []string         `json:"primary_tools,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigExperimentalParam) MarshalJSON 

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

func (*ConfigExperimentalParam) UnmarshalJSON 

func (r *ConfigExperimentalParam) UnmarshalJSON(data []byte) error

type ConfigFormatterMapItem 

type ConfigFormatterMapItem struct {
	Command     []string          `json:"command"`
	Disabled    bool              `json:"disabled"`
	Environment map[string]string `json:"environment"`
	Extensions  []string          `json:"extensions"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		Disabled    respjson.Field
		Environment respjson.Field
		Extensions  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigFormatterMapItem) RawJSON 

func (r ConfigFormatterMapItem) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigFormatterMapItem) UnmarshalJSON 

func (r *ConfigFormatterMapItem) UnmarshalJSON(data []byte) error

type ConfigFormatterMapItemParam 

type ConfigFormatterMapItemParam struct {
	Disabled    param.Opt[bool]   `json:"disabled,omitzero"`
	Command     []string          `json:"command,omitzero"`
	Environment map[string]string `json:"environment,omitzero"`
	Extensions  []string          `json:"extensions,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigFormatterMapItemParam) MarshalJSON 

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

func (*ConfigFormatterMapItemParam) UnmarshalJSON 

func (r *ConfigFormatterMapItemParam) UnmarshalJSON(data []byte) error

type ConfigFormatterUnion 

type ConfigFormatterUnion struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool bool `json:",inline"`
	// This field is from variant [map[string]ConfigFormatterMapItem].
	Command []string `json:"command"`
	// This field is from variant [map[string]ConfigFormatterMapItem].
	Disabled bool `json:"disabled"`
	// This field is from variant [map[string]ConfigFormatterMapItem].
	Environment map[string]string `json:"environment"`
	// This field is from variant [map[string]ConfigFormatterMapItem].
	Extensions []string `json:"extensions"`
	JSON       struct {
		OfBool      respjson.Field
		Command     respjson.Field
		Disabled    respjson.Field
		Environment respjson.Field
		Extensions  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigFormatterUnion contains all possible properties and values from [bool], [map[string]ConfigFormatterMapItem].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfBool]

func (ConfigFormatterUnion) AsBool 

func (u ConfigFormatterUnion) AsBool() (v bool)

func (ConfigFormatterUnion) AsConfigFormatterMapMap 

func (u ConfigFormatterUnion) AsConfigFormatterMapMap() (v map[string]ConfigFormatterMapItem)

func (ConfigFormatterUnion) RawJSON 

func (u ConfigFormatterUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigFormatterUnion) UnmarshalJSON 

func (r *ConfigFormatterUnion) UnmarshalJSON(data []byte) error

type ConfigFormatterUnionParam 

type ConfigFormatterUnionParam struct {
	OfBool                  param.Opt[bool]                        `json:",omitzero,inline"`
	OfConfigFormatterMapMap map[string]ConfigFormatterMapItemParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigFormatterUnionParam) MarshalJSON 

func (u ConfigFormatterUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigFormatterUnionParam) UnmarshalJSON 

func (u *ConfigFormatterUnionParam) UnmarshalJSON(data []byte) error

type ConfigGetParams 

type ConfigGetParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ConfigGetParams) URLQuery 

func (r ConfigGetParams) URLQuery() (v url.Values, err error)

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

type ConfigLayout 

type ConfigLayout string

@deprecated Always uses stretch layout. 

const (
	ConfigLayoutAuto    ConfigLayout = "auto"
	ConfigLayoutStretch ConfigLayout = "stretch"
)

type ConfigListProvidersParams 

type ConfigListProvidersParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ConfigListProvidersParams) URLQuery 

func (r ConfigListProvidersParams) URLQuery() (v url.Values, err error)

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

type ConfigListProvidersResponse 

type ConfigListProvidersResponse struct {
	Default   map[string]string `json:"default" api:"required"`
	Providers []Provider        `json:"providers" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Default     respjson.Field
		Providers   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

List of providers

func (ConfigListProvidersResponse) RawJSON 

func (r ConfigListProvidersResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigListProvidersResponse) UnmarshalJSON 

func (r *ConfigListProvidersResponse) UnmarshalJSON(data []byte) error

type ConfigLogLevel 

type ConfigLogLevel string

Log level 

const (
	ConfigLogLevelDebug ConfigLogLevel = "DEBUG"
	ConfigLogLevelInfo  ConfigLogLevel = "INFO"
	ConfigLogLevelWarn  ConfigLogLevel = "WARN"
	ConfigLogLevelError ConfigLogLevel = "ERROR"
)

type ConfigLspMapItemDisabled 

type ConfigLspMapItemDisabled struct {
	// Any of true.
	Disabled bool `json:"disabled" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Disabled    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigLspMapItemDisabled) RawJSON 

func (r ConfigLspMapItemDisabled) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigLspMapItemDisabled) UnmarshalJSON 

func (r *ConfigLspMapItemDisabled) UnmarshalJSON(data []byte) error

type ConfigLspMapItemDisabledParam 

type ConfigLspMapItemDisabledParam struct {
	// Any of true.
	Disabled bool `json:"disabled,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The property Disabled is required.

func (ConfigLspMapItemDisabledParam) MarshalJSON 

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

func (*ConfigLspMapItemDisabledParam) UnmarshalJSON 

func (r *ConfigLspMapItemDisabledParam) UnmarshalJSON(data []byte) error

type ConfigLspMapItemObject 

type ConfigLspMapItemObject struct {
	Command        []string          `json:"command" api:"required"`
	Disabled       bool              `json:"disabled"`
	Env            map[string]string `json:"env"`
	Extensions     []string          `json:"extensions"`
	Initialization map[string]any    `json:"initialization"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command        respjson.Field
		Disabled       respjson.Field
		Env            respjson.Field
		Extensions     respjson.Field
		Initialization respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigLspMapItemObject) RawJSON 

func (r ConfigLspMapItemObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigLspMapItemObject) UnmarshalJSON 

func (r *ConfigLspMapItemObject) UnmarshalJSON(data []byte) error

type ConfigLspMapItemObjectParam 

type ConfigLspMapItemObjectParam struct {
	Command        []string          `json:"command,omitzero" api:"required"`
	Disabled       param.Opt[bool]   `json:"disabled,omitzero"`
	Env            map[string]string `json:"env,omitzero"`
	Extensions     []string          `json:"extensions,omitzero"`
	Initialization map[string]any    `json:"initialization,omitzero"`
	// contains filtered or unexported fields
}

The property Command is required.

func (ConfigLspMapItemObjectParam) MarshalJSON 

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

func (*ConfigLspMapItemObjectParam) UnmarshalJSON 

func (r *ConfigLspMapItemObjectParam) UnmarshalJSON(data []byte) error

type ConfigLspMapItemUnion 

type ConfigLspMapItemUnion struct {
	Disabled bool `json:"disabled"`
	// This field is from variant [ConfigLspMapItemObject].
	Command []string `json:"command"`
	// This field is from variant [ConfigLspMapItemObject].
	Env map[string]string `json:"env"`
	// This field is from variant [ConfigLspMapItemObject].
	Extensions []string `json:"extensions"`
	// This field is from variant [ConfigLspMapItemObject].
	Initialization map[string]any `json:"initialization"`
	JSON           struct {
		Disabled       respjson.Field
		Command        respjson.Field
		Env            respjson.Field
		Extensions     respjson.Field
		Initialization respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigLspMapItemUnion contains all possible properties and values from ConfigLspMapItemDisabled, ConfigLspMapItemObject.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (ConfigLspMapItemUnion) AsConfigLspMapItemDisabled 

func (u ConfigLspMapItemUnion) AsConfigLspMapItemDisabled() (v ConfigLspMapItemDisabled)

func (ConfigLspMapItemUnion) AsConfigLspMapItemObject 

func (u ConfigLspMapItemUnion) AsConfigLspMapItemObject() (v ConfigLspMapItemObject)

func (ConfigLspMapItemUnion) RawJSON 

func (u ConfigLspMapItemUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigLspMapItemUnion) UnmarshalJSON 

func (r *ConfigLspMapItemUnion) UnmarshalJSON(data []byte) error

type ConfigLspMapItemUnionParam 

type ConfigLspMapItemUnionParam struct {
	OfConfigLspMapItemDisabled *ConfigLspMapItemDisabledParam `json:",omitzero,inline"`
	OfConfigLspMapItemObject   *ConfigLspMapItemObjectParam   `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigLspMapItemUnionParam) MarshalJSON 

func (u ConfigLspMapItemUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigLspMapItemUnionParam) UnmarshalJSON 

func (u *ConfigLspMapItemUnionParam) UnmarshalJSON(data []byte) error

type ConfigLspUnion 

type ConfigLspUnion struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool   bool `json:",inline"`
	Disabled bool `json:"disabled"`
	// This field is from variant [map[string]ConfigLspMapItemUnion].
	Command []string `json:"command"`
	// This field is from variant [map[string]ConfigLspMapItemUnion].
	Env map[string]string `json:"env"`
	// This field is from variant [map[string]ConfigLspMapItemUnion].
	Extensions []string `json:"extensions"`
	// This field is from variant [map[string]ConfigLspMapItemUnion].
	Initialization map[string]any `json:"initialization"`
	JSON           struct {
		OfBool         respjson.Field
		Disabled       respjson.Field
		Command        respjson.Field
		Env            respjson.Field
		Extensions     respjson.Field
		Initialization respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigLspUnion contains all possible properties and values from [bool], [map[string]ConfigLspMapItemUnion].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfBool]

func (ConfigLspUnion) AsBool 

func (u ConfigLspUnion) AsBool() (v bool)

func (ConfigLspUnion) AsConfigLspMapMap 

func (u ConfigLspUnion) AsConfigLspMapMap() (v map[string]ConfigLspMapItemUnion)

func (ConfigLspUnion) RawJSON 

func (u ConfigLspUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigLspUnion) UnmarshalJSON 

func (r *ConfigLspUnion) UnmarshalJSON(data []byte) error

type ConfigLspUnionParam 

type ConfigLspUnionParam struct {
	OfBool            param.Opt[bool]                       `json:",omitzero,inline"`
	OfConfigLspMapMap map[string]ConfigLspMapItemUnionParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigLspUnionParam) MarshalJSON 

func (u ConfigLspUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigLspUnionParam) UnmarshalJSON 

func (u *ConfigLspUnionParam) UnmarshalJSON(data []byte) error

type ConfigMcpEnabled 

type ConfigMcpEnabled struct {
	Enabled bool `json:"enabled" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Enabled     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigMcpEnabled) RawJSON 

func (r ConfigMcpEnabled) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigMcpEnabled) UnmarshalJSON 

func (r *ConfigMcpEnabled) UnmarshalJSON(data []byte) error

type ConfigMcpEnabledParam 

type ConfigMcpEnabledParam struct {
	Enabled bool `json:"enabled" api:"required"`
	// contains filtered or unexported fields
}

The property Enabled is required.

func (ConfigMcpEnabledParam) MarshalJSON 

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

func (*ConfigMcpEnabledParam) UnmarshalJSON 

func (r *ConfigMcpEnabledParam) UnmarshalJSON(data []byte) error

type ConfigMcpMcpLocalConfig 

type ConfigMcpMcpLocalConfig struct {
	// Command and arguments to run the MCP server
	Command []string `json:"command" api:"required"`
	// Type of MCP server connection
	//
	// Any of "local".
	Type        string            `json:"type" api:"required"`
	Enabled     bool              `json:"enabled"`
	Environment map[string]string `json:"environment"`
	Timeout     int64             `json:"timeout"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		Type        respjson.Field
		Enabled     respjson.Field
		Environment respjson.Field
		Timeout     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigMcpMcpLocalConfig) RawJSON 

func (r ConfigMcpMcpLocalConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigMcpMcpLocalConfig) UnmarshalJSON 

func (r *ConfigMcpMcpLocalConfig) UnmarshalJSON(data []byte) error

type ConfigMcpMcpLocalConfigParam 

type ConfigMcpMcpLocalConfigParam struct {
	// Command and arguments to run the MCP server
	Command []string `json:"command,omitzero" api:"required"`
	// Type of MCP server connection
	//
	// Any of "local".
	Type        string            `json:"type,omitzero" api:"required"`
	Enabled     param.Opt[bool]   `json:"enabled,omitzero"`
	Timeout     param.Opt[int64]  `json:"timeout,omitzero"`
	Environment map[string]string `json:"environment,omitzero"`
	// contains filtered or unexported fields
}

The properties Command, Type are required.

func (ConfigMcpMcpLocalConfigParam) MarshalJSON 

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

func (*ConfigMcpMcpLocalConfigParam) UnmarshalJSON 

func (r *ConfigMcpMcpLocalConfigParam) UnmarshalJSON(data []byte) error

type ConfigMcpMcpRemoteConfig 

type ConfigMcpMcpRemoteConfig struct {
	// Type of MCP server connection
	//
	// Any of "remote".
	Type string `json:"type" api:"required"`
	// URL of the remote MCP server
	URL     string            `json:"url" api:"required"`
	Enabled bool              `json:"enabled"`
	Headers map[string]string `json:"headers"`
	// OAuth authentication configuration for the MCP server. Set to false to disable
	// OAuth auto-detection.
	OAuth   ConfigMcpMcpRemoteConfigOAuthUnion `json:"oauth"`
	Timeout int64                              `json:"timeout"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Enabled     respjson.Field
		Headers     respjson.Field
		OAuth       respjson.Field
		Timeout     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigMcpMcpRemoteConfig) RawJSON 

func (r ConfigMcpMcpRemoteConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigMcpMcpRemoteConfig) UnmarshalJSON 

func (r *ConfigMcpMcpRemoteConfig) UnmarshalJSON(data []byte) error

type ConfigMcpMcpRemoteConfigOAuthBoolean 

type ConfigMcpMcpRemoteConfigOAuthBoolean bool
const (
	ConfigMcpMcpRemoteConfigOAuthBooleanFalse ConfigMcpMcpRemoteConfigOAuthBoolean = false
)

type ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig 

type ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig struct {
	ClientID     string `json:"clientId"`
	ClientSecret string `json:"clientSecret"`
	RedirectUri  string `json:"redirectUri"`
	Scope        string `json:"scope"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ClientID     respjson.Field
		ClientSecret respjson.Field
		RedirectUri  respjson.Field
		Scope        respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig) RawJSON 

func (r ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig) UnmarshalJSON 

func (r *ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig) UnmarshalJSON(data []byte) error

type ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfigParam 

type ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfigParam struct {
	ClientID     param.Opt[string] `json:"clientId,omitzero"`
	ClientSecret param.Opt[string] `json:"clientSecret,omitzero"`
	RedirectUri  param.Opt[string] `json:"redirectUri,omitzero"`
	Scope        param.Opt[string] `json:"scope,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfigParam) MarshalJSON 

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

func (*ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfigParam) UnmarshalJSON 

func (r *ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfigParam) UnmarshalJSON(data []byte) error

type ConfigMcpMcpRemoteConfigOAuthUnion 

type ConfigMcpMcpRemoteConfigOAuthUnion struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfConfigMcpMcpRemoteConfigOAuthBoolean bool `json:",inline"`
	// This field is from variant [ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig].
	ClientID string `json:"clientId"`
	// This field is from variant [ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig].
	ClientSecret string `json:"clientSecret"`
	// This field is from variant [ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig].
	RedirectUri string `json:"redirectUri"`
	// This field is from variant [ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig].
	Scope string `json:"scope"`
	JSON  struct {
		OfConfigMcpMcpRemoteConfigOAuthBoolean respjson.Field
		ClientID                               respjson.Field
		ClientSecret                           respjson.Field
		RedirectUri                            respjson.Field
		Scope                                  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigMcpMcpRemoteConfigOAuthUnion contains all possible properties and values from ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig, [bool].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfConfigMcpMcpRemoteConfigOAuthBoolean]

func (ConfigMcpMcpRemoteConfigOAuthUnion) AsConfigMcpMcpRemoteConfigOAuthBoolean 

func (u ConfigMcpMcpRemoteConfigOAuthUnion) AsConfigMcpMcpRemoteConfigOAuthBoolean() (v bool)

func (ConfigMcpMcpRemoteConfigOAuthUnion) AsConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig 

func (u ConfigMcpMcpRemoteConfigOAuthUnion) AsConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig() (v ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig)

func (ConfigMcpMcpRemoteConfigOAuthUnion) RawJSON 

func (u ConfigMcpMcpRemoteConfigOAuthUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigMcpMcpRemoteConfigOAuthUnion) UnmarshalJSON 

func (r *ConfigMcpMcpRemoteConfigOAuthUnion) UnmarshalJSON(data []byte) error

type ConfigMcpMcpRemoteConfigOAuthUnionParam 

type ConfigMcpMcpRemoteConfigOAuthUnionParam struct {
	OfConfigMcpMcpRemoteConfigOAuthMcpOAuthConfig *ConfigMcpMcpRemoteConfigOAuthMcpOAuthConfigParam `json:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfConfigMcpMcpRemoteConfigOAuthBoolean)
	OfConfigMcpMcpRemoteConfigOAuthBoolean param.Opt[bool] `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigMcpMcpRemoteConfigOAuthUnionParam) MarshalJSON 

func (u ConfigMcpMcpRemoteConfigOAuthUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigMcpMcpRemoteConfigOAuthUnionParam) UnmarshalJSON 

func (u *ConfigMcpMcpRemoteConfigOAuthUnionParam) UnmarshalJSON(data []byte) error

type ConfigMcpMcpRemoteConfigParam 

type ConfigMcpMcpRemoteConfigParam struct {
	// Type of MCP server connection
	//
	// Any of "remote".
	Type string `json:"type,omitzero" api:"required"`
	// URL of the remote MCP server
	URL     string            `json:"url" api:"required"`
	Enabled param.Opt[bool]   `json:"enabled,omitzero"`
	Timeout param.Opt[int64]  `json:"timeout,omitzero"`
	Headers map[string]string `json:"headers,omitzero"`
	// OAuth authentication configuration for the MCP server. Set to false to disable
	// OAuth auto-detection.
	OAuth ConfigMcpMcpRemoteConfigOAuthUnionParam `json:"oauth,omitzero"`
	// contains filtered or unexported fields
}

The properties Type, URL are required.

func (ConfigMcpMcpRemoteConfigParam) MarshalJSON 

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

func (*ConfigMcpMcpRemoteConfigParam) UnmarshalJSON 

func (r *ConfigMcpMcpRemoteConfigParam) UnmarshalJSON(data []byte) error

type ConfigMcpUnion 

type ConfigMcpUnion struct {
	// This field is from variant [ConfigMcpMcpLocalConfig].
	Command []string `json:"command"`
	Type    string   `json:"type"`
	Enabled bool     `json:"enabled"`
	// This field is from variant [ConfigMcpMcpLocalConfig].
	Environment map[string]string `json:"environment"`
	Timeout     int64             `json:"timeout"`
	// This field is from variant [ConfigMcpMcpRemoteConfig].
	URL string `json:"url"`
	// This field is from variant [ConfigMcpMcpRemoteConfig].
	Headers map[string]string `json:"headers"`
	// This field is from variant [ConfigMcpMcpRemoteConfig].
	OAuth ConfigMcpMcpRemoteConfigOAuthUnion `json:"oauth"`
	JSON  struct {
		Command     respjson.Field
		Type        respjson.Field
		Enabled     respjson.Field
		Environment respjson.Field
		Timeout     respjson.Field
		URL         respjson.Field
		Headers     respjson.Field
		OAuth       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigMcpUnion contains all possible properties and values from ConfigMcpMcpLocalConfig, ConfigMcpMcpRemoteConfig, ConfigMcpEnabled.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (ConfigMcpUnion) AsConfigMcpEnabled 

func (u ConfigMcpUnion) AsConfigMcpEnabled() (v ConfigMcpEnabled)

func (ConfigMcpUnion) AsConfigMcpMcpLocalConfig 

func (u ConfigMcpUnion) AsConfigMcpMcpLocalConfig() (v ConfigMcpMcpLocalConfig)

func (ConfigMcpUnion) AsConfigMcpMcpRemoteConfig 

func (u ConfigMcpUnion) AsConfigMcpMcpRemoteConfig() (v ConfigMcpMcpRemoteConfig)

func (ConfigMcpUnion) RawJSON 

func (u ConfigMcpUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigMcpUnion) UnmarshalJSON 

func (r *ConfigMcpUnion) UnmarshalJSON(data []byte) error

type ConfigMcpUnionParam 

type ConfigMcpUnionParam struct {
	OfConfigMcpMcpLocalConfig  *ConfigMcpMcpLocalConfigParam  `json:",omitzero,inline"`
	OfConfigMcpMcpRemoteConfig *ConfigMcpMcpRemoteConfigParam `json:",omitzero,inline"`
	OfConfigMcpEnabled         *ConfigMcpEnabledParam         `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigMcpUnionParam) MarshalJSON 

func (u ConfigMcpUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigMcpUnionParam) UnmarshalJSON 

func (u *ConfigMcpUnionParam) UnmarshalJSON(data []byte) error

type ConfigMode 

type ConfigMode struct {
	Build       AgentConfig            `json:"build"`
	Plan        AgentConfig            `json:"plan"`
	ExtraFields map[string]AgentConfig `json:"" api:"extrafields"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Build       respjson.Field
		Plan        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigMode) RawJSON 

func (r ConfigMode) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigMode) UnmarshalJSON 

func (r *ConfigMode) UnmarshalJSON(data []byte) error

type ConfigModeParam 

type ConfigModeParam struct {
	Build       AgentConfigParam            `json:"build,omitzero"`
	Plan        AgentConfigParam            `json:"plan,omitzero"`
	ExtraFields map[string]AgentConfigParam `json:"-"`
	// contains filtered or unexported fields
}

func (ConfigModeParam) MarshalJSON 

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

func (*ConfigModeParam) UnmarshalJSON 

func (r *ConfigModeParam) UnmarshalJSON(data []byte) error

type ConfigParam 

type ConfigParam struct {
	Schema       param.Opt[string]     `json:"$schema,omitzero"`
	Autoshare    param.Opt[bool]       `json:"autoshare,omitzero"`
	DefaultAgent param.Opt[string]     `json:"default_agent,omitzero"`
	Model        param.Opt[string]     `json:"model,omitzero"`
	Shell        param.Opt[string]     `json:"shell,omitzero"`
	SmallModel   param.Opt[string]     `json:"small_model,omitzero"`
	Snapshot     param.Opt[bool]       `json:"snapshot,omitzero"`
	Username     param.Opt[string]     `json:"username,omitzero"`
	Agent        ConfigAgentParam      `json:"agent,omitzero"`
	Attachment   ConfigAttachmentParam `json:"attachment,omitzero"`
	// Automatically update to the latest version. Set to true to auto-update, false to
	// disable, or 'notify' to show update notifications
	Autoupdate        ConfigAutoupdateUnionParam    `json:"autoupdate,omitzero"`
	Command           map[string]ConfigCommandParam `json:"command,omitzero"`
	Compaction        ConfigCompactionParam         `json:"compaction,omitzero"`
	DisabledProviders []string                      `json:"disabled_providers,omitzero"`
	EnabledProviders  []string                      `json:"enabled_providers,omitzero"`
	Enterprise        ConfigEnterpriseParam         `json:"enterprise,omitzero"`
	Experimental      ConfigExperimentalParam       `json:"experimental,omitzero"`
	// Enable or configure formatters. Omit or set to false to disable, true to enable
	// built-ins, or an object to enable built-ins with overrides.
	Formatter    ConfigFormatterUnionParam `json:"formatter,omitzero"`
	Instructions []string                  `json:"instructions,omitzero"`
	// @deprecated Always uses stretch layout.
	//
	// Any of "auto", "stretch".
	Layout ConfigLayout `json:"layout,omitzero"`
	// Log level
	//
	// Any of "DEBUG", "INFO", "WARN", "ERROR".
	LogLevel ConfigLogLevel `json:"logLevel,omitzero"`
	// Enable or configure LSP servers. Omit or set to false to disable, true to enable
	// built-ins, or an object to enable built-ins with overrides.
	Lsp        ConfigLspUnionParam                  `json:"lsp,omitzero"`
	Mcp        map[string]ConfigMcpUnionParam       `json:"mcp,omitzero"`
	Mode       ConfigModeParam                      `json:"mode,omitzero"`
	Permission PermissionConfigUnionParam           `json:"permission,omitzero"`
	Plugin     []ConfigPluginUnionParam             `json:"plugin,omitzero"`
	Provider   map[string]ConfigProviderParam       `json:"provider,omitzero"`
	Reference  map[string]ConfigReferenceUnionParam `json:"reference,omitzero"`
	// Server configuration for opencode serve and web commands
	Server ConfigServerParam `json:"server,omitzero"`
	// Any of "manual", "auto", "disabled".
	Share      ConfigShare           `json:"share,omitzero"`
	Skills     ConfigSkillsParam     `json:"skills,omitzero"`
	ToolOutput ConfigToolOutputParam `json:"tool_output,omitzero"`
	Tools      map[string]bool       `json:"tools,omitzero"`
	Watcher    ConfigWatcherParam    `json:"watcher,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigParam) MarshalJSON 

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

func (*ConfigParam) UnmarshalJSON 

func (r *ConfigParam) UnmarshalJSON(data []byte) error

type ConfigPluginUnion 

type ConfigPluginUnion struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field will be present if the value is a [[]any] instead of an object.
	OfAnyArray []any `json:",inline"`
	JSON       struct {
		OfString   respjson.Field
		OfAnyArray respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigPluginUnion contains all possible properties and values from [string], [[]any].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfString OfAnyArray]

func (ConfigPluginUnion) AsAnyArray 

func (u ConfigPluginUnion) AsAnyArray() (v []any)

func (ConfigPluginUnion) AsString 

func (u ConfigPluginUnion) AsString() (v string)

func (ConfigPluginUnion) RawJSON 

func (u ConfigPluginUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigPluginUnion) UnmarshalJSON 

func (r *ConfigPluginUnion) UnmarshalJSON(data []byte) error

type ConfigPluginUnionParam 

type ConfigPluginUnionParam struct {
	OfString   param.Opt[string] `json:",omitzero,inline"`
	OfAnyArray []any             `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigPluginUnionParam) MarshalJSON 

func (u ConfigPluginUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigPluginUnionParam) UnmarshalJSON 

func (u *ConfigPluginUnionParam) UnmarshalJSON(data []byte) error

type ConfigProvider 

type ConfigProvider struct {
	ID        string                         `json:"id"`
	API       string                         `json:"api"`
	Blacklist []string                       `json:"blacklist"`
	Env       []string                       `json:"env"`
	Models    map[string]ConfigProviderModel `json:"models"`
	Name      string                         `json:"name"`
	Npm       string                         `json:"npm"`
	Options   ConfigProviderOptions          `json:"options"`
	Whitelist []string                       `json:"whitelist"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		API         respjson.Field
		Blacklist   respjson.Field
		Env         respjson.Field
		Models      respjson.Field
		Name        respjson.Field
		Npm         respjson.Field
		Options     respjson.Field
		Whitelist   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProvider) RawJSON 

func (r ConfigProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProvider) UnmarshalJSON 

func (r *ConfigProvider) UnmarshalJSON(data []byte) error

type ConfigProviderModel 

type ConfigProviderModel struct {
	ID           string                              `json:"id"`
	Attachment   bool                                `json:"attachment"`
	Cost         ConfigProviderModelCost             `json:"cost"`
	Experimental bool                                `json:"experimental"`
	Family       string                              `json:"family"`
	Headers      map[string]string                   `json:"headers"`
	Interleaved  ConfigProviderModelInterleavedUnion `json:"interleaved"`
	Limit        ConfigProviderModelLimit            `json:"limit"`
	Modalities   ConfigProviderModelModalities       `json:"modalities"`
	Name         string                              `json:"name"`
	Options      map[string]any                      `json:"options"`
	Provider     ConfigProviderModelProvider         `json:"provider"`
	Reasoning    bool                                `json:"reasoning"`
	ReleaseDate  string                              `json:"release_date"`
	// Any of "alpha", "beta", "deprecated", "active".
	Status      string `json:"status"`
	Temperature bool   `json:"temperature"`
	ToolCall    bool   `json:"tool_call"`
	// Variant-specific configuration
	Variants map[string]ConfigProviderModelVariant `json:"variants"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID           respjson.Field
		Attachment   respjson.Field
		Cost         respjson.Field
		Experimental respjson.Field
		Family       respjson.Field
		Headers      respjson.Field
		Interleaved  respjson.Field
		Limit        respjson.Field
		Modalities   respjson.Field
		Name         respjson.Field
		Options      respjson.Field
		Provider     respjson.Field
		Reasoning    respjson.Field
		ReleaseDate  respjson.Field
		Status       respjson.Field
		Temperature  respjson.Field
		ToolCall     respjson.Field
		Variants     respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModel) RawJSON 

func (r ConfigProviderModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModel) UnmarshalJSON 

func (r *ConfigProviderModel) UnmarshalJSON(data []byte) error

type ConfigProviderModelCost 

type ConfigProviderModelCost struct {
	Input           float64                                `json:"input" api:"required"`
	Output          float64                                `json:"output" api:"required"`
	CacheRead       float64                                `json:"cache_read"`
	CacheWrite      float64                                `json:"cache_write"`
	ContextOver200k ConfigProviderModelCostContextOver200k `json:"context_over_200k"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input           respjson.Field
		Output          respjson.Field
		CacheRead       respjson.Field
		CacheWrite      respjson.Field
		ContextOver200k respjson.Field
		ExtraFields     map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModelCost) RawJSON 

func (r ConfigProviderModelCost) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelCost) UnmarshalJSON 

func (r *ConfigProviderModelCost) UnmarshalJSON(data []byte) error

type ConfigProviderModelCostContextOver200k 

type ConfigProviderModelCostContextOver200k struct {
	Input      float64 `json:"input" api:"required"`
	Output     float64 `json:"output" api:"required"`
	CacheRead  float64 `json:"cache_read"`
	CacheWrite float64 `json:"cache_write"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input       respjson.Field
		Output      respjson.Field
		CacheRead   respjson.Field
		CacheWrite  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModelCostContextOver200k) RawJSON 

func (r ConfigProviderModelCostContextOver200k) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelCostContextOver200k) UnmarshalJSON 

func (r *ConfigProviderModelCostContextOver200k) UnmarshalJSON(data []byte) error

type ConfigProviderModelCostContextOver200kParam 

type ConfigProviderModelCostContextOver200kParam struct {
	Input      float64            `json:"input" api:"required"`
	Output     float64            `json:"output" api:"required"`
	CacheRead  param.Opt[float64] `json:"cache_read,omitzero"`
	CacheWrite param.Opt[float64] `json:"cache_write,omitzero"`
	// contains filtered or unexported fields
}

The properties Input, Output are required.

func (ConfigProviderModelCostContextOver200kParam) MarshalJSON 

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

func (*ConfigProviderModelCostContextOver200kParam) UnmarshalJSON 

func (r *ConfigProviderModelCostContextOver200kParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelCostParam 

type ConfigProviderModelCostParam struct {
	Input           float64                                     `json:"input" api:"required"`
	Output          float64                                     `json:"output" api:"required"`
	CacheRead       param.Opt[float64]                          `json:"cache_read,omitzero"`
	CacheWrite      param.Opt[float64]                          `json:"cache_write,omitzero"`
	ContextOver200k ConfigProviderModelCostContextOver200kParam `json:"context_over_200k,omitzero"`
	// contains filtered or unexported fields
}

The properties Input, Output are required.

func (ConfigProviderModelCostParam) MarshalJSON 

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

func (*ConfigProviderModelCostParam) UnmarshalJSON 

func (r *ConfigProviderModelCostParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelInterleavedBoolean 

type ConfigProviderModelInterleavedBoolean bool
const (
	ConfigProviderModelInterleavedBooleanTrue ConfigProviderModelInterleavedBoolean = true
)

type ConfigProviderModelInterleavedField 

type ConfigProviderModelInterleavedField struct {
	// Any of "reasoning_content", "reasoning_details".
	Field string `json:"field" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Field       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModelInterleavedField) RawJSON 

func (r ConfigProviderModelInterleavedField) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelInterleavedField) UnmarshalJSON 

func (r *ConfigProviderModelInterleavedField) UnmarshalJSON(data []byte) error

type ConfigProviderModelInterleavedFieldParam 

type ConfigProviderModelInterleavedFieldParam struct {
	// Any of "reasoning_content", "reasoning_details".
	Field string `json:"field,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The property Field is required.

func (ConfigProviderModelInterleavedFieldParam) MarshalJSON 

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

func (*ConfigProviderModelInterleavedFieldParam) UnmarshalJSON 

func (r *ConfigProviderModelInterleavedFieldParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelInterleavedUnion 

type ConfigProviderModelInterleavedUnion struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfConfigProviderModelInterleavedBoolean bool `json:",inline"`
	// This field is from variant [ConfigProviderModelInterleavedField].
	Field string `json:"field"`
	JSON  struct {
		OfConfigProviderModelInterleavedBoolean respjson.Field
		Field                                   respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigProviderModelInterleavedUnion contains all possible properties and values from [bool], ConfigProviderModelInterleavedField.

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfConfigProviderModelInterleavedBoolean]

func (ConfigProviderModelInterleavedUnion) AsConfigProviderModelInterleavedBoolean 

func (u ConfigProviderModelInterleavedUnion) AsConfigProviderModelInterleavedBoolean() (v bool)

func (ConfigProviderModelInterleavedUnion) AsConfigProviderModelInterleavedField 

func (u ConfigProviderModelInterleavedUnion) AsConfigProviderModelInterleavedField() (v ConfigProviderModelInterleavedField)

func (ConfigProviderModelInterleavedUnion) RawJSON 

func (u ConfigProviderModelInterleavedUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelInterleavedUnion) UnmarshalJSON 

func (r *ConfigProviderModelInterleavedUnion) UnmarshalJSON(data []byte) error

type ConfigProviderModelInterleavedUnionParam 

type ConfigProviderModelInterleavedUnionParam struct {
	// Check if union is this variant with
	// !param.IsOmitted(union.OfConfigProviderModelInterleavedBoolean)
	OfConfigProviderModelInterleavedBoolean param.Opt[bool]                           `json:",omitzero,inline"`
	OfConfigProviderModelInterleavedField   *ConfigProviderModelInterleavedFieldParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigProviderModelInterleavedUnionParam) MarshalJSON 

func (u ConfigProviderModelInterleavedUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigProviderModelInterleavedUnionParam) UnmarshalJSON 

func (u *ConfigProviderModelInterleavedUnionParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelLimit 

type ConfigProviderModelLimit struct {
	Context float64 `json:"context" api:"required"`
	Output  float64 `json:"output" api:"required"`
	Input   float64 `json:"input"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Context     respjson.Field
		Output      respjson.Field
		Input       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModelLimit) RawJSON 

func (r ConfigProviderModelLimit) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelLimit) UnmarshalJSON 

func (r *ConfigProviderModelLimit) UnmarshalJSON(data []byte) error

type ConfigProviderModelLimitParam 

type ConfigProviderModelLimitParam struct {
	Context float64            `json:"context" api:"required"`
	Output  float64            `json:"output" api:"required"`
	Input   param.Opt[float64] `json:"input,omitzero"`
	// contains filtered or unexported fields
}

The properties Context, Output are required.

func (ConfigProviderModelLimitParam) MarshalJSON 

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

func (*ConfigProviderModelLimitParam) UnmarshalJSON 

func (r *ConfigProviderModelLimitParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelModalities 

type ConfigProviderModelModalities struct {
	// Any of "text", "audio", "image", "video", "pdf".
	Input []string `json:"input" api:"required"`
	// Any of "text", "audio", "image", "video", "pdf".
	Output []string `json:"output" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input       respjson.Field
		Output      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModelModalities) RawJSON 

func (r ConfigProviderModelModalities) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelModalities) UnmarshalJSON 

func (r *ConfigProviderModelModalities) UnmarshalJSON(data []byte) error

type ConfigProviderModelModalitiesParam 

type ConfigProviderModelModalitiesParam struct {
	// Any of "text", "audio", "image", "video", "pdf".
	Input []string `json:"input,omitzero" api:"required"`
	// Any of "text", "audio", "image", "video", "pdf".
	Output []string `json:"output,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Input, Output are required.

func (ConfigProviderModelModalitiesParam) MarshalJSON 

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

func (*ConfigProviderModelModalitiesParam) UnmarshalJSON 

func (r *ConfigProviderModelModalitiesParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelParam 

type ConfigProviderModelParam struct {
	ID           param.Opt[string]                        `json:"id,omitzero"`
	Attachment   param.Opt[bool]                          `json:"attachment,omitzero"`
	Experimental param.Opt[bool]                          `json:"experimental,omitzero"`
	Family       param.Opt[string]                        `json:"family,omitzero"`
	Name         param.Opt[string]                        `json:"name,omitzero"`
	Reasoning    param.Opt[bool]                          `json:"reasoning,omitzero"`
	ReleaseDate  param.Opt[string]                        `json:"release_date,omitzero"`
	Temperature  param.Opt[bool]                          `json:"temperature,omitzero"`
	ToolCall     param.Opt[bool]                          `json:"tool_call,omitzero"`
	Cost         ConfigProviderModelCostParam             `json:"cost,omitzero"`
	Headers      map[string]string                        `json:"headers,omitzero"`
	Interleaved  ConfigProviderModelInterleavedUnionParam `json:"interleaved,omitzero"`
	Limit        ConfigProviderModelLimitParam            `json:"limit,omitzero"`
	Modalities   ConfigProviderModelModalitiesParam       `json:"modalities,omitzero"`
	Options      map[string]any                           `json:"options,omitzero"`
	Provider     ConfigProviderModelProviderParam         `json:"provider,omitzero"`
	// Any of "alpha", "beta", "deprecated", "active".
	Status string `json:"status,omitzero"`
	// Variant-specific configuration
	Variants map[string]ConfigProviderModelVariantParam `json:"variants,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigProviderModelParam) MarshalJSON 

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

func (*ConfigProviderModelParam) UnmarshalJSON 

func (r *ConfigProviderModelParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelProvider 

type ConfigProviderModelProvider struct {
	API string `json:"api"`
	Npm string `json:"npm"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		API         respjson.Field
		Npm         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModelProvider) RawJSON 

func (r ConfigProviderModelProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelProvider) UnmarshalJSON 

func (r *ConfigProviderModelProvider) UnmarshalJSON(data []byte) error

type ConfigProviderModelProviderParam 

type ConfigProviderModelProviderParam struct {
	API param.Opt[string] `json:"api,omitzero"`
	Npm param.Opt[string] `json:"npm,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigProviderModelProviderParam) MarshalJSON 

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

func (*ConfigProviderModelProviderParam) UnmarshalJSON 

func (r *ConfigProviderModelProviderParam) UnmarshalJSON(data []byte) error

type ConfigProviderModelVariant 

type ConfigProviderModelVariant struct {
	Disabled    bool           `json:"disabled"`
	ExtraFields map[string]any `json:"" api:"extrafields"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Disabled    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderModelVariant) RawJSON 

func (r ConfigProviderModelVariant) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderModelVariant) UnmarshalJSON 

func (r *ConfigProviderModelVariant) UnmarshalJSON(data []byte) error

type ConfigProviderModelVariantParam 

type ConfigProviderModelVariantParam struct {
	Disabled    param.Opt[bool] `json:"disabled,omitzero"`
	ExtraFields map[string]any  `json:"-"`
	// contains filtered or unexported fields
}

func (ConfigProviderModelVariantParam) MarshalJSON 

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

func (*ConfigProviderModelVariantParam) UnmarshalJSON 

func (r *ConfigProviderModelVariantParam) UnmarshalJSON(data []byte) error

type ConfigProviderOptions 

type ConfigProviderOptions struct {
	APIKey        string `json:"apiKey"`
	BaseURL       string `json:"baseURL"`
	ChunkTimeout  int64  `json:"chunkTimeout"`
	EnterpriseURL string `json:"enterpriseUrl"`
	SetCacheKey   bool   `json:"setCacheKey"`
	// Timeout in milliseconds for requests to this provider. Default is 300000 (5
	// minutes). Set to false to disable timeout.
	Timeout     ConfigProviderOptionsTimeoutUnion `json:"timeout"`
	ExtraFields map[string]any                    `json:"" api:"extrafields"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		APIKey        respjson.Field
		BaseURL       respjson.Field
		ChunkTimeout  respjson.Field
		EnterpriseURL respjson.Field
		SetCacheKey   respjson.Field
		Timeout       respjson.Field
		ExtraFields   map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigProviderOptions) RawJSON 

func (r ConfigProviderOptions) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderOptions) UnmarshalJSON 

func (r *ConfigProviderOptions) UnmarshalJSON(data []byte) error

type ConfigProviderOptionsParam 

type ConfigProviderOptionsParam struct {
	APIKey        param.Opt[string] `json:"apiKey,omitzero"`
	BaseURL       param.Opt[string] `json:"baseURL,omitzero"`
	ChunkTimeout  param.Opt[int64]  `json:"chunkTimeout,omitzero"`
	EnterpriseURL param.Opt[string] `json:"enterpriseUrl,omitzero"`
	SetCacheKey   param.Opt[bool]   `json:"setCacheKey,omitzero"`
	// Timeout in milliseconds for requests to this provider. Default is 300000 (5
	// minutes). Set to false to disable timeout.
	Timeout     ConfigProviderOptionsTimeoutUnionParam `json:"timeout,omitzero"`
	ExtraFields map[string]any                         `json:"-"`
	// contains filtered or unexported fields
}

func (ConfigProviderOptionsParam) MarshalJSON 

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

func (*ConfigProviderOptionsParam) UnmarshalJSON 

func (r *ConfigProviderOptionsParam) UnmarshalJSON(data []byte) error

type ConfigProviderOptionsTimeoutBoolean 

type ConfigProviderOptionsTimeoutBoolean bool
const (
	ConfigProviderOptionsTimeoutBooleanFalse ConfigProviderOptionsTimeoutBoolean = false
)

type ConfigProviderOptionsTimeoutUnion 

type ConfigProviderOptionsTimeoutUnion struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field will be present if the value is a [bool] instead of an object.
	OfConfigProviderOptionsTimeoutBoolean bool `json:",inline"`
	JSON                                  struct {
		OfInt                                 respjson.Field
		OfConfigProviderOptionsTimeoutBoolean respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigProviderOptionsTimeoutUnion contains all possible properties and values from [int64], [bool].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfInt OfConfigProviderOptionsTimeoutBoolean]

func (ConfigProviderOptionsTimeoutUnion) AsConfigProviderOptionsTimeoutBoolean 

func (u ConfigProviderOptionsTimeoutUnion) AsConfigProviderOptionsTimeoutBoolean() (v bool)

func (ConfigProviderOptionsTimeoutUnion) AsInt 

func (u ConfigProviderOptionsTimeoutUnion) AsInt() (v int64)

func (ConfigProviderOptionsTimeoutUnion) RawJSON 

func (u ConfigProviderOptionsTimeoutUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigProviderOptionsTimeoutUnion) UnmarshalJSON 

func (r *ConfigProviderOptionsTimeoutUnion) UnmarshalJSON(data []byte) error

type ConfigProviderOptionsTimeoutUnionParam 

type ConfigProviderOptionsTimeoutUnionParam struct {
	OfInt param.Opt[int64] `json:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfConfigProviderOptionsTimeoutBoolean)
	OfConfigProviderOptionsTimeoutBoolean param.Opt[bool] `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigProviderOptionsTimeoutUnionParam) MarshalJSON 

func (u ConfigProviderOptionsTimeoutUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigProviderOptionsTimeoutUnionParam) UnmarshalJSON 

func (u *ConfigProviderOptionsTimeoutUnionParam) UnmarshalJSON(data []byte) error

type ConfigProviderParam 

type ConfigProviderParam struct {
	ID        param.Opt[string]                   `json:"id,omitzero"`
	API       param.Opt[string]                   `json:"api,omitzero"`
	Name      param.Opt[string]                   `json:"name,omitzero"`
	Npm       param.Opt[string]                   `json:"npm,omitzero"`
	Blacklist []string                            `json:"blacklist,omitzero"`
	Env       []string                            `json:"env,omitzero"`
	Models    map[string]ConfigProviderModelParam `json:"models,omitzero"`
	Options   ConfigProviderOptionsParam          `json:"options,omitzero"`
	Whitelist []string                            `json:"whitelist,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigProviderParam) MarshalJSON 

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

func (*ConfigProviderParam) UnmarshalJSON 

func (r *ConfigProviderParam) UnmarshalJSON(data []byte) error

type ConfigReferenceObject 

type ConfigReferenceObject struct {
	// Git repository URL, host/path reference, or GitHub owner/repo shorthand
	Repository string `json:"repository" api:"required"`
	Branch     string `json:"branch"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Repository  respjson.Field
		Branch      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigReferenceObject) RawJSON 

func (r ConfigReferenceObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigReferenceObject) UnmarshalJSON 

func (r *ConfigReferenceObject) UnmarshalJSON(data []byte) error

type ConfigReferenceObjectParam 

type ConfigReferenceObjectParam struct {
	// Git repository URL, host/path reference, or GitHub owner/repo shorthand
	Repository string            `json:"repository" api:"required"`
	Branch     param.Opt[string] `json:"branch,omitzero"`
	// contains filtered or unexported fields
}

The property Repository is required.

func (ConfigReferenceObjectParam) MarshalJSON 

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

func (*ConfigReferenceObjectParam) UnmarshalJSON 

func (r *ConfigReferenceObjectParam) UnmarshalJSON(data []byte) error

type ConfigReferencePath 

type ConfigReferencePath struct {
	// Absolute path, ~/ path, or workspace-relative path to a local reference
	// directory
	Path string `json:"path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Path        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigReferencePath) RawJSON 

func (r ConfigReferencePath) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigReferencePath) UnmarshalJSON 

func (r *ConfigReferencePath) UnmarshalJSON(data []byte) error

type ConfigReferencePathParam 

type ConfigReferencePathParam struct {
	// Absolute path, ~/ path, or workspace-relative path to a local reference
	// directory
	Path string `json:"path" api:"required"`
	// contains filtered or unexported fields
}

The property Path is required.

func (ConfigReferencePathParam) MarshalJSON 

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

func (*ConfigReferencePathParam) UnmarshalJSON 

func (r *ConfigReferencePathParam) UnmarshalJSON(data []byte) error

type ConfigReferenceUnion 

type ConfigReferenceUnion struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field is from variant [ConfigReferenceObject].
	Repository string `json:"repository"`
	// This field is from variant [ConfigReferenceObject].
	Branch string `json:"branch"`
	// This field is from variant [ConfigReferencePath].
	Path string `json:"path"`
	JSON struct {
		OfString   respjson.Field
		Repository respjson.Field
		Branch     respjson.Field
		Path       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ConfigReferenceUnion contains all possible properties and values from [string], ConfigReferenceObject, ConfigReferencePath.

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfString]

func (ConfigReferenceUnion) AsConfigReferenceObject 

func (u ConfigReferenceUnion) AsConfigReferenceObject() (v ConfigReferenceObject)

func (ConfigReferenceUnion) AsConfigReferencePath 

func (u ConfigReferenceUnion) AsConfigReferencePath() (v ConfigReferencePath)

func (ConfigReferenceUnion) AsString 

func (u ConfigReferenceUnion) AsString() (v string)

func (ConfigReferenceUnion) RawJSON 

func (u ConfigReferenceUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigReferenceUnion) UnmarshalJSON 

func (r *ConfigReferenceUnion) UnmarshalJSON(data []byte) error

type ConfigReferenceUnionParam 

type ConfigReferenceUnionParam struct {
	OfString                param.Opt[string]           `json:",omitzero,inline"`
	OfConfigReferenceObject *ConfigReferenceObjectParam `json:",omitzero,inline"`
	OfConfigReferencePath   *ConfigReferencePathParam   `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (ConfigReferenceUnionParam) MarshalJSON 

func (u ConfigReferenceUnionParam) MarshalJSON() ([]byte, error)

func (*ConfigReferenceUnionParam) UnmarshalJSON 

func (u *ConfigReferenceUnionParam) UnmarshalJSON(data []byte) error

type ConfigServer 

type ConfigServer struct {
	Cors       []string `json:"cors"`
	Hostname   string   `json:"hostname"`
	Mdns       bool     `json:"mdns"`
	MdnsDomain string   `json:"mdnsDomain"`
	Port       int64    `json:"port"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cors        respjson.Field
		Hostname    respjson.Field
		Mdns        respjson.Field
		MdnsDomain  respjson.Field
		Port        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Server configuration for opencode serve and web commands

func (ConfigServer) RawJSON 

func (r ConfigServer) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigServer) UnmarshalJSON 

func (r *ConfigServer) UnmarshalJSON(data []byte) error

type ConfigServerParam 

type ConfigServerParam struct {
	Hostname   param.Opt[string] `json:"hostname,omitzero"`
	Mdns       param.Opt[bool]   `json:"mdns,omitzero"`
	MdnsDomain param.Opt[string] `json:"mdnsDomain,omitzero"`
	Port       param.Opt[int64]  `json:"port,omitzero"`
	Cors       []string          `json:"cors,omitzero"`
	// contains filtered or unexported fields
}

Server configuration for opencode serve and web commands

func (ConfigServerParam) MarshalJSON 

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

func (*ConfigServerParam) UnmarshalJSON 

func (r *ConfigServerParam) UnmarshalJSON(data []byte) error

type ConfigService 

type ConfigService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi config routes.

ConfigService contains methods and other services that help with interacting with the opencode-stainless 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 NewConfigService method instead.

func NewConfigService 

func NewConfigService(opts ...option.RequestOption) (r ConfigService)

NewConfigService 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 (*ConfigService) Get 

func (r *ConfigService) Get(ctx context.Context, query ConfigGetParams, opts ...option.RequestOption) (res *Config, err error)

Retrieve the current OpenCode configuration settings and preferences.

func (*ConfigService) ListProviders 

func (r *ConfigService) ListProviders(ctx context.Context, query ConfigListProvidersParams, opts ...option.RequestOption) (res *ConfigListProvidersResponse, err error)

Get a list of all configured AI providers and their default models.

func (*ConfigService) Update 

func (r *ConfigService) Update(ctx context.Context, params ConfigUpdateParams, opts ...option.RequestOption) (res *Config, err error)

Update OpenCode configuration settings and preferences.

type ConfigShare 

type ConfigShare string
const (
	ConfigShareManual   ConfigShare = "manual"
	ConfigShareAuto     ConfigShare = "auto"
	ConfigShareDisabled ConfigShare = "disabled"
)

type ConfigSkills 

type ConfigSkills struct {
	Paths []string `json:"paths"`
	URLs  []string `json:"urls"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Paths       respjson.Field
		URLs        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigSkills) RawJSON 

func (r ConfigSkills) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigSkills) UnmarshalJSON 

func (r *ConfigSkills) UnmarshalJSON(data []byte) error

type ConfigSkillsParam 

type ConfigSkillsParam struct {
	Paths []string `json:"paths,omitzero"`
	URLs  []string `json:"urls,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigSkillsParam) MarshalJSON 

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

func (*ConfigSkillsParam) UnmarshalJSON 

func (r *ConfigSkillsParam) UnmarshalJSON(data []byte) error

type ConfigToolOutput 

type ConfigToolOutput struct {
	MaxBytes int64 `json:"max_bytes"`
	MaxLines int64 `json:"max_lines"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MaxBytes    respjson.Field
		MaxLines    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigToolOutput) RawJSON 

func (r ConfigToolOutput) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigToolOutput) UnmarshalJSON 

func (r *ConfigToolOutput) UnmarshalJSON(data []byte) error

type ConfigToolOutputParam 

type ConfigToolOutputParam struct {
	MaxBytes param.Opt[int64] `json:"max_bytes,omitzero"`
	MaxLines param.Opt[int64] `json:"max_lines,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigToolOutputParam) MarshalJSON 

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

func (*ConfigToolOutputParam) UnmarshalJSON 

func (r *ConfigToolOutputParam) UnmarshalJSON(data []byte) error

type ConfigUpdateParams 

type ConfigUpdateParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Config    ConfigParam
	// contains filtered or unexported fields
}

func (ConfigUpdateParams) MarshalJSON 

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

func (ConfigUpdateParams) URLQuery 

func (r ConfigUpdateParams) URLQuery() (v url.Values, err error)

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

func (*ConfigUpdateParams) UnmarshalJSON 

func (r *ConfigUpdateParams) UnmarshalJSON(data []byte) error

type ConfigWatcher 

type ConfigWatcher struct {
	Ignore []string `json:"ignore"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ignore      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigWatcher) RawJSON 

func (r ConfigWatcher) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigWatcher) UnmarshalJSON 

func (r *ConfigWatcher) UnmarshalJSON(data []byte) error

type ConfigWatcherParam 

type ConfigWatcherParam struct {
	Ignore []string `json:"ignore,omitzero"`
	// contains filtered or unexported fields
}

func (ConfigWatcherParam) MarshalJSON 

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

func (*ConfigWatcherParam) UnmarshalJSON 

func (r *ConfigWatcherParam) UnmarshalJSON(data []byte) error

type ContextOverflowError 

type ContextOverflowError struct {
	Data ContextOverflowErrorData `json:"data" api:"required"`
	// Any of "ContextOverflowError".
	Name ContextOverflowErrorName `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ContextOverflowError) RawJSON 

func (r ContextOverflowError) RawJSON() string

Returns the unmodified JSON received from the API

func (*ContextOverflowError) UnmarshalJSON 

func (r *ContextOverflowError) UnmarshalJSON(data []byte) error

type ContextOverflowErrorData 

type ContextOverflowErrorData struct {
	Message      string `json:"message" api:"required"`
	ResponseBody string `json:"responseBody"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message      respjson.Field
		ResponseBody respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ContextOverflowErrorData) RawJSON 

func (r ContextOverflowErrorData) RawJSON() string

Returns the unmodified JSON received from the API

func (*ContextOverflowErrorData) UnmarshalJSON 

func (r *ContextOverflowErrorData) UnmarshalJSON(data []byte) error

type ContextOverflowErrorName 

type ContextOverflowErrorName string
const (
	ContextOverflowErrorNameContextOverflowError ContextOverflowErrorName = "ContextOverflowError"
)

type Error 

type Error = apierror.Error

type EventCatalogModelUpdated 

type EventCatalogModelUpdated struct {
	ID         string                             `json:"id" api:"required"`
	Properties EventCatalogModelUpdatedProperties `json:"properties" api:"required"`
	// Any of "catalog.model.updated".
	Type EventCatalogModelUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventCatalogModelUpdated) RawJSON 

func (r EventCatalogModelUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventCatalogModelUpdated) UnmarshalJSON 

func (r *EventCatalogModelUpdated) UnmarshalJSON(data []byte) error

type EventCatalogModelUpdatedProperties 

type EventCatalogModelUpdatedProperties struct {
	Model ModelV2Info `json:"model" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Model       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventCatalogModelUpdatedProperties) RawJSON 

func (r EventCatalogModelUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventCatalogModelUpdatedProperties) UnmarshalJSON 

func (r *EventCatalogModelUpdatedProperties) UnmarshalJSON(data []byte) error

type EventCatalogModelUpdatedType 

type EventCatalogModelUpdatedType string
const (
	EventCatalogModelUpdatedTypeCatalogModelUpdated EventCatalogModelUpdatedType = "catalog.model.updated"
)

type EventCommandExecuted 

type EventCommandExecuted struct {
	ID         string                         `json:"id" api:"required"`
	Properties EventCommandExecutedProperties `json:"properties" api:"required"`
	// Any of "command.executed".
	Type EventCommandExecutedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventCommandExecuted) RawJSON 

func (r EventCommandExecuted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventCommandExecuted) UnmarshalJSON 

func (r *EventCommandExecuted) UnmarshalJSON(data []byte) error

type EventCommandExecutedProperties 

type EventCommandExecutedProperties struct {
	Arguments string `json:"arguments" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	Name      string `json:"name" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Arguments   respjson.Field
		MessageID   respjson.Field
		Name        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventCommandExecutedProperties) RawJSON 

func (r EventCommandExecutedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventCommandExecutedProperties) UnmarshalJSON 

func (r *EventCommandExecutedProperties) UnmarshalJSON(data []byte) error

type EventCommandExecutedType 

type EventCommandExecutedType string
const (
	EventCommandExecutedTypeCommandExecuted EventCommandExecutedType = "command.executed"
)

type EventFileEdited 

type EventFileEdited struct {
	ID         string                    `json:"id" api:"required"`
	Properties EventFileEditedProperties `json:"properties" api:"required"`
	// Any of "file.edited".
	Type EventFileEditedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventFileEdited) RawJSON 

func (r EventFileEdited) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventFileEdited) UnmarshalJSON 

func (r *EventFileEdited) UnmarshalJSON(data []byte) error

type EventFileEditedProperties 

type EventFileEditedProperties struct {
	File string `json:"file" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		File        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventFileEditedProperties) RawJSON 

func (r EventFileEditedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventFileEditedProperties) UnmarshalJSON 

func (r *EventFileEditedProperties) UnmarshalJSON(data []byte) error

type EventFileEditedType 

type EventFileEditedType string
const (
	EventFileEditedTypeFileEdited EventFileEditedType = "file.edited"
)

type EventFileWatcherUpdated 

type EventFileWatcherUpdated struct {
	ID         string                            `json:"id" api:"required"`
	Properties EventFileWatcherUpdatedProperties `json:"properties" api:"required"`
	// Any of "file.watcher.updated".
	Type EventFileWatcherUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventFileWatcherUpdated) RawJSON 

func (r EventFileWatcherUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventFileWatcherUpdated) UnmarshalJSON 

func (r *EventFileWatcherUpdated) UnmarshalJSON(data []byte) error

type EventFileWatcherUpdatedProperties 

type EventFileWatcherUpdatedProperties struct {
	// Any of "add", "change", "unlink".
	Event string `json:"event" api:"required"`
	File  string `json:"file" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Event       respjson.Field
		File        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventFileWatcherUpdatedProperties) RawJSON 

func (r EventFileWatcherUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventFileWatcherUpdatedProperties) UnmarshalJSON 

func (r *EventFileWatcherUpdatedProperties) UnmarshalJSON(data []byte) error

type EventFileWatcherUpdatedType 

type EventFileWatcherUpdatedType string
const (
	EventFileWatcherUpdatedTypeFileWatcherUpdated EventFileWatcherUpdatedType = "file.watcher.updated"
)

type EventGlobalDisposed 

type EventGlobalDisposed struct {
	ID         string         `json:"id" api:"required"`
	Properties map[string]any `json:"properties" api:"required"`
	// Any of "global.disposed".
	Type EventGlobalDisposedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventGlobalDisposed) RawJSON 

func (r EventGlobalDisposed) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventGlobalDisposed) UnmarshalJSON 

func (r *EventGlobalDisposed) UnmarshalJSON(data []byte) error

type EventGlobalDisposedType 

type EventGlobalDisposedType string
const (
	EventGlobalDisposedTypeGlobalDisposed EventGlobalDisposedType = "global.disposed"
)

type EventInstallationUpdateAvailable 

type EventInstallationUpdateAvailable struct {
	ID         string                                     `json:"id" api:"required"`
	Properties EventInstallationUpdateAvailableProperties `json:"properties" api:"required"`
	// Any of "installation.update-available".
	Type EventInstallationUpdateAvailableType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventInstallationUpdateAvailable) RawJSON 

func (r EventInstallationUpdateAvailable) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventInstallationUpdateAvailable) UnmarshalJSON 

func (r *EventInstallationUpdateAvailable) UnmarshalJSON(data []byte) error

type EventInstallationUpdateAvailableProperties 

type EventInstallationUpdateAvailableProperties struct {
	Version string `json:"version" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Version     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventInstallationUpdateAvailableProperties) RawJSON 

func (r EventInstallationUpdateAvailableProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventInstallationUpdateAvailableProperties) UnmarshalJSON 

func (r *EventInstallationUpdateAvailableProperties) UnmarshalJSON(data []byte) error

type EventInstallationUpdateAvailableType 

type EventInstallationUpdateAvailableType string
const (
	EventInstallationUpdateAvailableTypeInstallationUpdateAvailable EventInstallationUpdateAvailableType = "installation.update-available"
)

type EventInstallationUpdated 

type EventInstallationUpdated struct {
	ID         string                             `json:"id" api:"required"`
	Properties EventInstallationUpdatedProperties `json:"properties" api:"required"`
	// Any of "installation.updated".
	Type EventInstallationUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventInstallationUpdated) RawJSON 

func (r EventInstallationUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventInstallationUpdated) UnmarshalJSON 

func (r *EventInstallationUpdated) UnmarshalJSON(data []byte) error

type EventInstallationUpdatedProperties 

type EventInstallationUpdatedProperties struct {
	Version string `json:"version" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Version     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventInstallationUpdatedProperties) RawJSON 

func (r EventInstallationUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventInstallationUpdatedProperties) UnmarshalJSON 

func (r *EventInstallationUpdatedProperties) UnmarshalJSON(data []byte) error

type EventInstallationUpdatedType 

type EventInstallationUpdatedType string
const (
	EventInstallationUpdatedTypeInstallationUpdated EventInstallationUpdatedType = "installation.updated"
)

type EventListParams 

type EventListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (EventListParams) URLQuery 

func (r EventListParams) URLQuery() (v url.Values, err error)

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

type EventListResponseEventTuiToastShow1 

type EventListResponseEventTuiToastShow1 struct {
	ID         string                                        `json:"id" api:"required"`
	Properties EventListResponseEventTuiToastShow1Properties `json:"properties" api:"required"`
	// Any of "tui.toast.show".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventListResponseEventTuiToastShow1) RawJSON 

func (r EventListResponseEventTuiToastShow1) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventListResponseEventTuiToastShow1) UnmarshalJSON 

func (r *EventListResponseEventTuiToastShow1) UnmarshalJSON(data []byte) error

type EventListResponseEventTuiToastShow1Properties 

type EventListResponseEventTuiToastShow1Properties struct {
	Message string `json:"message" api:"required"`
	// Any of "info", "success", "warning", "error".
	Variant  string `json:"variant" api:"required"`
	Duration int64  `json:"duration"`
	Title    string `json:"title"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Variant     respjson.Field
		Duration    respjson.Field
		Title       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventListResponseEventTuiToastShow1Properties) RawJSON 

func (r EventListResponseEventTuiToastShow1Properties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventListResponseEventTuiToastShow1Properties) UnmarshalJSON 

func (r *EventListResponseEventTuiToastShow1Properties) UnmarshalJSON(data []byte) error

type EventListResponseUnion 

type EventListResponseUnion struct {
	ID string `json:"id"`
	// This field is a union of [EventServerInstanceDisposedProperties],
	// [PermissionRequest], [EventPermissionRepliedProperties],
	// [EventLspClientDiagnosticsProperties], [map[string]any],
	// [EventMessagePartDeltaProperties], [EventSessionDiffProperties],
	// [EventSessionErrorProperties], [EventTuiPromptAppendProperties],
	// [EventTuiCommandExecuteProperties],
	// [EventListResponseEventTuiToastShow1Properties],
	// [EventTuiSessionSelectProperties], [EventInstallationUpdatedProperties],
	// [EventInstallationUpdateAvailableProperties], [EventMcpToolsChangedProperties],
	// [EventMcpBrowserOpenFailedProperties], [EventCommandExecutedProperties],
	// [Project], [EventFileEditedProperties], [EventFileWatcherUpdatedProperties],
	// [EventVcsBranchUpdatedProperties], [EventWorktreeReadyProperties],
	// [EventWorktreeFailedProperties], [QuestionRequest],
	// [EventQuestionRepliedProperties], [EventQuestionRejectedProperties],
	// [EventTodoUpdatedProperties], [EventSessionStatusProperties],
	// [EventSessionIdleProperties], [EventSessionCompactedProperties],
	// [EventWorkspaceReadyProperties], [EventWorkspaceFailedProperties],
	// [EventWorkspaceStatusProperties], [EventPtyCreatedProperties],
	// [EventPtyUpdatedProperties], [EventPtyExitedProperties],
	// [EventPtyDeletedProperties], [EventMessageUpdatedProperties],
	// [EventMessageRemovedProperties], [EventMessagePartUpdatedProperties],
	// [EventMessagePartRemovedProperties], [EventSessionCreatedProperties],
	// [EventSessionUpdatedProperties], [EventSessionDeletedProperties],
	// [EventSessionNextAgentSwitchedProperties],
	// [EventSessionNextModelSwitchedProperties], [EventSessionNextPromptedProperties],
	// [EventSessionNextSyntheticProperties], [EventSessionNextShellStartedProperties],
	// [EventSessionNextShellEndedProperties], [EventSessionNextStepStartedProperties],
	// [EventSessionNextStepEndedProperties], [EventSessionNextStepFailedProperties],
	// [EventSessionNextTextStartedProperties], [EventSessionNextTextDeltaProperties],
	// [EventSessionNextTextEndedProperties],
	// [EventSessionNextReasoningStartedProperties],
	// [EventSessionNextReasoningDeltaProperties],
	// [EventSessionNextReasoningEndedProperties],
	// [EventSessionNextToolInputStartedProperties],
	// [EventSessionNextToolInputDeltaProperties],
	// [EventSessionNextToolInputEndedProperties],
	// [EventSessionNextToolCalledProperties],
	// [EventSessionNextToolProgressProperties],
	// [EventSessionNextToolSuccessProperties], [EventSessionNextToolFailedProperties],
	// [EventSessionNextRetriedProperties],
	// [EventSessionNextCompactionStartedProperties],
	// [EventSessionNextCompactionDeltaProperties],
	// [EventSessionNextCompactionEndedProperties], [map[string]any], [map[string]any],
	// [EventCatalogModelUpdatedProperties]
	Properties EventListResponseUnionProperties `json:"properties"`
	Type       string                           `json:"type"`
	JSON       struct {
		ID         respjson.Field
		Properties respjson.Field
		Type       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnion contains all possible properties and values from EventServerInstanceDisposed, EventPermissionAsked, EventPermissionReplied, EventLspClientDiagnostics, EventLspUpdated, EventMessagePartDelta, EventSessionDiff, EventSessionError, EventTuiPromptAppend, EventTuiCommandExecute, EventListResponseEventTuiToastShow1, EventTuiSessionSelect, EventInstallationUpdated, EventInstallationUpdateAvailable, EventMcpToolsChanged, EventMcpBrowserOpenFailed, EventCommandExecuted, EventProjectUpdated, EventFileEdited, EventFileWatcherUpdated, EventVcsBranchUpdated, EventWorktreeReady, EventWorktreeFailed, EventQuestionAsked, EventQuestionReplied, EventQuestionRejected, EventTodoUpdated, EventSessionStatus, EventSessionIdle, EventSessionCompacted, EventWorkspaceReady, EventWorkspaceFailed, EventWorkspaceStatus, EventPtyCreated, EventPtyUpdated, EventPtyExited, EventPtyDeleted, EventMessageUpdated, EventMessageRemoved, EventMessagePartUpdated, EventMessagePartRemoved, EventSessionCreated, EventSessionUpdated, EventSessionDeleted, EventSessionNextAgentSwitched, EventSessionNextModelSwitched, EventSessionNextPrompted, EventSessionNextSynthetic, EventSessionNextShellStarted, EventSessionNextShellEnded, EventSessionNextStepStarted, EventSessionNextStepEnded, EventSessionNextStepFailed, EventSessionNextTextStarted, EventSessionNextTextDelta, EventSessionNextTextEnded, EventSessionNextReasoningStarted, EventSessionNextReasoningDelta, EventSessionNextReasoningEnded, EventSessionNextToolInputStarted, EventSessionNextToolInputDelta, EventSessionNextToolInputEnded, EventSessionNextToolCalled, EventSessionNextToolProgress, EventSessionNextToolSuccess, EventSessionNextToolFailed, EventSessionNextRetried, EventSessionNextCompactionStarted, EventSessionNextCompactionDelta, EventSessionNextCompactionEnded, EventServerConnected, EventGlobalDisposed, EventCatalogModelUpdated, EventSessionNextAgentSwitched, EventSessionNextModelSwitched, EventSessionNextPrompted, EventSessionNextSynthetic, EventSessionNextShellStarted, EventSessionNextShellEnded, EventSessionNextStepStarted, EventSessionNextStepEnded, EventSessionNextStepFailed, EventSessionNextTextStarted, EventSessionNextTextDelta, EventSessionNextTextEnded, EventSessionNextReasoningStarted, EventSessionNextReasoningDelta, EventSessionNextReasoningEnded, EventSessionNextToolInputStarted, EventSessionNextToolInputDelta, EventSessionNextToolInputEnded, EventSessionNextToolCalled, EventSessionNextToolProgress, EventSessionNextToolSuccess, EventSessionNextToolFailed, EventSessionNextRetried, EventSessionNextCompactionStarted, EventSessionNextCompactionDelta, EventSessionNextCompactionEnded.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (EventListResponseUnion) AsEventCatalogModelUpdated 

func (u EventListResponseUnion) AsEventCatalogModelUpdated() (v EventCatalogModelUpdated)

func (EventListResponseUnion) AsEventCommandExecuted 

func (u EventListResponseUnion) AsEventCommandExecuted() (v EventCommandExecuted)

func (EventListResponseUnion) AsEventFileEdited 

func (u EventListResponseUnion) AsEventFileEdited() (v EventFileEdited)

func (EventListResponseUnion) AsEventFileWatcherUpdated 

func (u EventListResponseUnion) AsEventFileWatcherUpdated() (v EventFileWatcherUpdated)

func (EventListResponseUnion) AsEventGlobalDisposed 

func (u EventListResponseUnion) AsEventGlobalDisposed() (v EventGlobalDisposed)

func (EventListResponseUnion) AsEventInstallationUpdateAvailable 

func (u EventListResponseUnion) AsEventInstallationUpdateAvailable() (v EventInstallationUpdateAvailable)

func (EventListResponseUnion) AsEventInstallationUpdated 

func (u EventListResponseUnion) AsEventInstallationUpdated() (v EventInstallationUpdated)

func (EventListResponseUnion) AsEventListResponseEventTuiToastShow1 

func (u EventListResponseUnion) AsEventListResponseEventTuiToastShow1() (v EventListResponseEventTuiToastShow1)

func (EventListResponseUnion) AsEventLspClientDiagnostics 

func (u EventListResponseUnion) AsEventLspClientDiagnostics() (v EventLspClientDiagnostics)

func (EventListResponseUnion) AsEventLspUpdated 

func (u EventListResponseUnion) AsEventLspUpdated() (v EventLspUpdated)

func (EventListResponseUnion) AsEventMcpBrowserOpenFailed 

func (u EventListResponseUnion) AsEventMcpBrowserOpenFailed() (v EventMcpBrowserOpenFailed)

func (EventListResponseUnion) AsEventMcpToolsChanged 

func (u EventListResponseUnion) AsEventMcpToolsChanged() (v EventMcpToolsChanged)

func (EventListResponseUnion) AsEventMessagePartDelta 

func (u EventListResponseUnion) AsEventMessagePartDelta() (v EventMessagePartDelta)

func (EventListResponseUnion) AsEventMessagePartRemoved 

func (u EventListResponseUnion) AsEventMessagePartRemoved() (v EventMessagePartRemoved)

func (EventListResponseUnion) AsEventMessagePartUpdated 

func (u EventListResponseUnion) AsEventMessagePartUpdated() (v EventMessagePartUpdated)

func (EventListResponseUnion) AsEventMessageRemoved 

func (u EventListResponseUnion) AsEventMessageRemoved() (v EventMessageRemoved)

func (EventListResponseUnion) AsEventMessageUpdated 

func (u EventListResponseUnion) AsEventMessageUpdated() (v EventMessageUpdated)

func (EventListResponseUnion) AsEventPermissionAsked 

func (u EventListResponseUnion) AsEventPermissionAsked() (v EventPermissionAsked)

func (EventListResponseUnion) AsEventPermissionReplied 

func (u EventListResponseUnion) AsEventPermissionReplied() (v EventPermissionReplied)

func (EventListResponseUnion) AsEventProjectUpdated 

func (u EventListResponseUnion) AsEventProjectUpdated() (v EventProjectUpdated)

func (EventListResponseUnion) AsEventPtyCreated 

func (u EventListResponseUnion) AsEventPtyCreated() (v EventPtyCreated)

func (EventListResponseUnion) AsEventPtyDeleted 

func (u EventListResponseUnion) AsEventPtyDeleted() (v EventPtyDeleted)

func (EventListResponseUnion) AsEventPtyExited 

func (u EventListResponseUnion) AsEventPtyExited() (v EventPtyExited)

func (EventListResponseUnion) AsEventPtyUpdated 

func (u EventListResponseUnion) AsEventPtyUpdated() (v EventPtyUpdated)

func (EventListResponseUnion) AsEventQuestionAsked 

func (u EventListResponseUnion) AsEventQuestionAsked() (v EventQuestionAsked)

func (EventListResponseUnion) AsEventQuestionRejected 

func (u EventListResponseUnion) AsEventQuestionRejected() (v EventQuestionRejected)

func (EventListResponseUnion) AsEventQuestionReplied 

func (u EventListResponseUnion) AsEventQuestionReplied() (v EventQuestionReplied)

func (EventListResponseUnion) AsEventServerConnected 

func (u EventListResponseUnion) AsEventServerConnected() (v EventServerConnected)

func (EventListResponseUnion) AsEventServerInstanceDisposed 

func (u EventListResponseUnion) AsEventServerInstanceDisposed() (v EventServerInstanceDisposed)

func (EventListResponseUnion) AsEventSessionCompacted 

func (u EventListResponseUnion) AsEventSessionCompacted() (v EventSessionCompacted)

func (EventListResponseUnion) AsEventSessionCreated 

func (u EventListResponseUnion) AsEventSessionCreated() (v EventSessionCreated)

func (EventListResponseUnion) AsEventSessionDeleted 

func (u EventListResponseUnion) AsEventSessionDeleted() (v EventSessionDeleted)

func (EventListResponseUnion) AsEventSessionDiff 

func (u EventListResponseUnion) AsEventSessionDiff() (v EventSessionDiff)

func (EventListResponseUnion) AsEventSessionError 

func (u EventListResponseUnion) AsEventSessionError() (v EventSessionError)

func (EventListResponseUnion) AsEventSessionIdle 

func (u EventListResponseUnion) AsEventSessionIdle() (v EventSessionIdle)

func (EventListResponseUnion) AsEventSessionNextAgentSwitched 

func (u EventListResponseUnion) AsEventSessionNextAgentSwitched() (v EventSessionNextAgentSwitched)

func (EventListResponseUnion) AsEventSessionNextCompactionDelta 

func (u EventListResponseUnion) AsEventSessionNextCompactionDelta() (v EventSessionNextCompactionDelta)

func (EventListResponseUnion) AsEventSessionNextCompactionEnded 

func (u EventListResponseUnion) AsEventSessionNextCompactionEnded() (v EventSessionNextCompactionEnded)

func (EventListResponseUnion) AsEventSessionNextCompactionStarted 

func (u EventListResponseUnion) AsEventSessionNextCompactionStarted() (v EventSessionNextCompactionStarted)

func (EventListResponseUnion) AsEventSessionNextModelSwitched 

func (u EventListResponseUnion) AsEventSessionNextModelSwitched() (v EventSessionNextModelSwitched)

func (EventListResponseUnion) AsEventSessionNextPrompted 

func (u EventListResponseUnion) AsEventSessionNextPrompted() (v EventSessionNextPrompted)

func (EventListResponseUnion) AsEventSessionNextReasoningDelta 

func (u EventListResponseUnion) AsEventSessionNextReasoningDelta() (v EventSessionNextReasoningDelta)

func (EventListResponseUnion) AsEventSessionNextReasoningEnded 

func (u EventListResponseUnion) AsEventSessionNextReasoningEnded() (v EventSessionNextReasoningEnded)

func (EventListResponseUnion) AsEventSessionNextReasoningStarted 

func (u EventListResponseUnion) AsEventSessionNextReasoningStarted() (v EventSessionNextReasoningStarted)

func (EventListResponseUnion) AsEventSessionNextRetried 

func (u EventListResponseUnion) AsEventSessionNextRetried() (v EventSessionNextRetried)

func (EventListResponseUnion) AsEventSessionNextShellEnded 

func (u EventListResponseUnion) AsEventSessionNextShellEnded() (v EventSessionNextShellEnded)

func (EventListResponseUnion) AsEventSessionNextShellStarted 

func (u EventListResponseUnion) AsEventSessionNextShellStarted() (v EventSessionNextShellStarted)

func (EventListResponseUnion) AsEventSessionNextStepEnded 

func (u EventListResponseUnion) AsEventSessionNextStepEnded() (v EventSessionNextStepEnded)

func (EventListResponseUnion) AsEventSessionNextStepFailed 

func (u EventListResponseUnion) AsEventSessionNextStepFailed() (v EventSessionNextStepFailed)

func (EventListResponseUnion) AsEventSessionNextStepStarted 

func (u EventListResponseUnion) AsEventSessionNextStepStarted() (v EventSessionNextStepStarted)

func (EventListResponseUnion) AsEventSessionNextSynthetic 

func (u EventListResponseUnion) AsEventSessionNextSynthetic() (v EventSessionNextSynthetic)

func (EventListResponseUnion) AsEventSessionNextTextDelta 

func (u EventListResponseUnion) AsEventSessionNextTextDelta() (v EventSessionNextTextDelta)

func (EventListResponseUnion) AsEventSessionNextTextEnded 

func (u EventListResponseUnion) AsEventSessionNextTextEnded() (v EventSessionNextTextEnded)

func (EventListResponseUnion) AsEventSessionNextTextStarted 

func (u EventListResponseUnion) AsEventSessionNextTextStarted() (v EventSessionNextTextStarted)

func (EventListResponseUnion) AsEventSessionNextToolCalled 

func (u EventListResponseUnion) AsEventSessionNextToolCalled() (v EventSessionNextToolCalled)

func (EventListResponseUnion) AsEventSessionNextToolFailed 

func (u EventListResponseUnion) AsEventSessionNextToolFailed() (v EventSessionNextToolFailed)

func (EventListResponseUnion) AsEventSessionNextToolInputDelta 

func (u EventListResponseUnion) AsEventSessionNextToolInputDelta() (v EventSessionNextToolInputDelta)

func (EventListResponseUnion) AsEventSessionNextToolInputEnded 

func (u EventListResponseUnion) AsEventSessionNextToolInputEnded() (v EventSessionNextToolInputEnded)

func (EventListResponseUnion) AsEventSessionNextToolInputStarted 

func (u EventListResponseUnion) AsEventSessionNextToolInputStarted() (v EventSessionNextToolInputStarted)

func (EventListResponseUnion) AsEventSessionNextToolProgress 

func (u EventListResponseUnion) AsEventSessionNextToolProgress() (v EventSessionNextToolProgress)

func (EventListResponseUnion) AsEventSessionNextToolSuccess 

func (u EventListResponseUnion) AsEventSessionNextToolSuccess() (v EventSessionNextToolSuccess)

func (EventListResponseUnion) AsEventSessionStatus 

func (u EventListResponseUnion) AsEventSessionStatus() (v EventSessionStatus)

func (EventListResponseUnion) AsEventSessionUpdated 

func (u EventListResponseUnion) AsEventSessionUpdated() (v EventSessionUpdated)

func (EventListResponseUnion) AsEventTodoUpdated 

func (u EventListResponseUnion) AsEventTodoUpdated() (v EventTodoUpdated)

func (EventListResponseUnion) AsEventTuiCommandExecute 

func (u EventListResponseUnion) AsEventTuiCommandExecute() (v EventTuiCommandExecute)

func (EventListResponseUnion) AsEventTuiPromptAppend 

func (u EventListResponseUnion) AsEventTuiPromptAppend() (v EventTuiPromptAppend)

func (EventListResponseUnion) AsEventTuiSessionSelect 

func (u EventListResponseUnion) AsEventTuiSessionSelect() (v EventTuiSessionSelect)

func (EventListResponseUnion) AsEventVcsBranchUpdated 

func (u EventListResponseUnion) AsEventVcsBranchUpdated() (v EventVcsBranchUpdated)

func (EventListResponseUnion) AsEventWorkspaceFailed 

func (u EventListResponseUnion) AsEventWorkspaceFailed() (v EventWorkspaceFailed)

func (EventListResponseUnion) AsEventWorkspaceReady 

func (u EventListResponseUnion) AsEventWorkspaceReady() (v EventWorkspaceReady)

func (EventListResponseUnion) AsEventWorkspaceStatus 

func (u EventListResponseUnion) AsEventWorkspaceStatus() (v EventWorkspaceStatus)

func (EventListResponseUnion) AsEventWorktreeFailed 

func (u EventListResponseUnion) AsEventWorktreeFailed() (v EventWorktreeFailed)

func (EventListResponseUnion) AsEventWorktreeReady 

func (u EventListResponseUnion) AsEventWorktreeReady() (v EventWorktreeReady)

func (EventListResponseUnion) AsVariant2 

func (u EventListResponseUnion) AsVariant2() (v EventSessionNextAgentSwitched)

func (EventListResponseUnion) AsVariant3 

func (u EventListResponseUnion) AsVariant3() (v EventSessionNextCompactionEnded)

func (EventListResponseUnion) RawJSON 

func (u EventListResponseUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventListResponseUnion) UnmarshalJSON 

func (r *EventListResponseUnion) UnmarshalJSON(data []byte) error

type EventListResponseUnionProperties 

type EventListResponseUnionProperties struct {
	// This field will be present if the value is a [any] instead of an object.
	OfEventGlobalDisposedProperty any `json:",inline"`
	// This field is from variant [EventServerInstanceDisposedProperties].
	Directory string `json:"directory"`
	ID        string `json:"id"`
	// This field is from variant [PermissionRequest].
	Always []string `json:"always"`
	// This field is from variant [PermissionRequest].
	Metadata map[string]any `json:"metadata"`
	// This field is from variant [PermissionRequest].
	Patterns []string `json:"patterns"`
	// This field is from variant [PermissionRequest].
	Permission string `json:"permission"`
	SessionID  string `json:"sessionID"`
	// This field is a union of [PermissionRequestTool], [QuestionRequestTool],
	// [string]
	Tool EventListResponseUnionPropertiesTool `json:"tool"`
	// This field is from variant [EventPermissionRepliedProperties].
	Reply     string `json:"reply"`
	RequestID string `json:"requestID"`
	// This field is from variant [EventLspClientDiagnosticsProperties].
	Path string `json:"path"`
	// This field is from variant [EventLspClientDiagnosticsProperties].
	ServerID string `json:"serverID"`
	Delta    string `json:"delta"`
	// This field is from variant [EventMessagePartDeltaProperties].
	Field     string `json:"field"`
	MessageID string `json:"messageID"`
	PartID    string `json:"partID"`
	// This field is from variant [EventSessionDiffProperties].
	Diff []SnapshotFileDiff `json:"diff"`
	// This field is a union of [EventSessionErrorPropertiesErrorUnion],
	// [SessionErrorUnknown], [SessionNextRetryError]
	Error   EventListResponseUnionPropertiesError `json:"error"`
	Text    string                                `json:"text"`
	Command string                                `json:"command"`
	Message string                                `json:"message"`
	// This field is from variant [EventListResponseEventTuiToastShow1Properties].
	Variant string `json:"variant"`
	// This field is from variant [EventListResponseEventTuiToastShow1Properties].
	Duration int64 `json:"duration"`
	// This field is from variant [EventListResponseEventTuiToastShow1Properties].
	Title   string `json:"title"`
	Version string `json:"version"`
	// This field is from variant [EventMcpToolsChangedProperties].
	Server string `json:"server"`
	// This field is from variant [EventMcpBrowserOpenFailedProperties].
	McpName string `json:"mcpName"`
	// This field is from variant [EventMcpBrowserOpenFailedProperties].
	URL string `json:"url"`
	// This field is from variant [EventCommandExecutedProperties].
	Arguments string `json:"arguments"`
	Name      string `json:"name"`
	// This field is from variant [Project].
	Sandboxes []string `json:"sandboxes"`
	// This field is a union of [ProjectTime], [int64]
	Time EventListResponseUnionPropertiesTime `json:"time"`
	// This field is from variant [Project].
	Worktree string `json:"worktree"`
	// This field is from variant [Project].
	Commands ProjectCommands `json:"commands"`
	// This field is from variant [Project].
	Icon ProjectIcon `json:"icon"`
	// This field is from variant [Project].
	Vcs  ProjectVcs `json:"vcs"`
	File string     `json:"file"`
	// This field is from variant [EventFileWatcherUpdatedProperties].
	Event  string `json:"event"`
	Branch string `json:"branch"`
	// This field is from variant [QuestionRequest].
	Questions []QuestionRequestQuestion `json:"questions"`
	// This field is from variant [EventQuestionRepliedProperties].
	Answers [][]string `json:"answers"`
	// This field is from variant [EventTodoUpdatedProperties].
	Todos []Todo `json:"todos"`
	// This field is a union of [EventSessionStatusPropertiesStatusUnion], [string]
	Status EventListResponseUnionPropertiesStatus `json:"status"`
	// This field is from variant [EventWorkspaceStatusProperties].
	WorkspaceID string `json:"workspaceID"`
	// This field is a union of [Pty], [MessageUnion], [Session]
	Info EventListResponseUnionPropertiesInfo `json:"info"`
	// This field is from variant [EventPtyExitedProperties].
	ExitCode int64 `json:"exitCode"`
	// This field is from variant [EventMessagePartUpdatedProperties].
	Part      PartUnion `json:"part"`
	Agent     string    `json:"agent"`
	Timestamp float64   `json:"timestamp"`
	// This field is a union of [EventSessionNextModelSwitchedPropertiesModel],
	// [EventSessionNextStepStartedPropertiesModel], [ModelV2Info]
	Model EventListResponseUnionPropertiesModel `json:"model"`
	// This field is from variant [EventSessionNextPromptedProperties].
	Prompt Prompt `json:"prompt"`
	CallID string `json:"callID"`
	// This field is from variant [EventSessionNextShellEndedProperties].
	Output   string `json:"output"`
	Snapshot string `json:"snapshot"`
	// This field is from variant [EventSessionNextStepEndedProperties].
	Cost float64 `json:"cost"`
	// This field is from variant [EventSessionNextStepEndedProperties].
	Finish string `json:"finish"`
	// This field is from variant [EventSessionNextStepEndedProperties].
	Tokens      EventSessionNextStepEndedPropertiesTokens `json:"tokens"`
	ReasoningID string                                    `json:"reasoningID"`
	// This field is from variant [EventSessionNextToolCalledProperties].
	Input map[string]any `json:"input"`
	// This field is a union of [EventSessionNextToolCalledPropertiesProvider],
	// [EventSessionNextToolSuccessPropertiesProvider],
	// [EventSessionNextToolFailedPropertiesProvider]
	Provider EventListResponseUnionPropertiesProvider `json:"provider"`
	// This field is a union of [[]EventSessionNextToolProgressPropertiesContentUnion],
	// [[]EventSessionNextToolSuccessPropertiesContentUnion]
	Content    EventListResponseUnionPropertiesContent `json:"content"`
	Structured any                                     `json:"structured"`
	// This field is from variant [EventSessionNextRetriedProperties].
	Attempt float64 `json:"attempt"`
	// This field is from variant [EventSessionNextCompactionStartedProperties].
	Reason string `json:"reason"`
	// This field is from variant [EventSessionNextCompactionEndedProperties].
	Include string `json:"include"`
	JSON    struct {
		OfEventGlobalDisposedProperty respjson.Field
		Directory                     respjson.Field
		ID                            respjson.Field
		Always                        respjson.Field
		Metadata                      respjson.Field
		Patterns                      respjson.Field
		Permission                    respjson.Field
		SessionID                     respjson.Field
		Tool                          respjson.Field
		Reply                         respjson.Field
		RequestID                     respjson.Field
		Path                          respjson.Field
		ServerID                      respjson.Field
		Delta                         respjson.Field
		Field                         respjson.Field
		MessageID                     respjson.Field
		PartID                        respjson.Field
		Diff                          respjson.Field
		Error                         respjson.Field
		Text                          respjson.Field
		Command                       respjson.Field
		Message                       respjson.Field
		Variant                       respjson.Field
		Duration                      respjson.Field
		Title                         respjson.Field
		Version                       respjson.Field
		Server                        respjson.Field
		McpName                       respjson.Field
		URL                           respjson.Field
		Arguments                     respjson.Field
		Name                          respjson.Field
		Sandboxes                     respjson.Field
		Time                          respjson.Field
		Worktree                      respjson.Field
		Commands                      respjson.Field
		Icon                          respjson.Field
		Vcs                           respjson.Field
		File                          respjson.Field
		Event                         respjson.Field
		Branch                        respjson.Field
		Questions                     respjson.Field
		Answers                       respjson.Field
		Todos                         respjson.Field
		Status                        respjson.Field
		WorkspaceID                   respjson.Field
		Info                          respjson.Field
		ExitCode                      respjson.Field
		Part                          respjson.Field
		Agent                         respjson.Field
		Timestamp                     respjson.Field
		Model                         respjson.Field
		Prompt                        respjson.Field
		CallID                        respjson.Field
		Output                        respjson.Field
		Snapshot                      respjson.Field
		Cost                          respjson.Field
		Finish                        respjson.Field
		Tokens                        respjson.Field
		ReasoningID                   respjson.Field
		Input                         respjson.Field
		Provider                      respjson.Field
		Content                       respjson.Field
		Structured                    respjson.Field
		Attempt                       respjson.Field
		Reason                        respjson.Field
		Include                       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionProperties is an implicit subunion of EventListResponseUnion. EventListResponseUnionProperties provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfEventGlobalDisposedProperty]

func (*EventListResponseUnionProperties) UnmarshalJSON 

func (r *EventListResponseUnionProperties) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesContent 

type EventListResponseUnionPropertiesContent struct {
	// This field will be present if the value is a
	// [[]EventSessionNextToolProgressPropertiesContentUnion] instead of an object.
	OfEventSessionNextToolProgressPropertiesContentArray []EventSessionNextToolProgressPropertiesContentUnion `json:",inline"`
	// This field will be present if the value is a
	// [[]EventSessionNextToolSuccessPropertiesContentUnion] instead of an object.
	OfEventSessionNextToolSuccessPropertiesContentArray []EventSessionNextToolSuccessPropertiesContentUnion `json:",inline"`
	JSON                                                struct {
		OfEventSessionNextToolProgressPropertiesContentArray respjson.Field
		OfEventSessionNextToolSuccessPropertiesContentArray  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesContent is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesContent provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfEventSessionNextToolProgressPropertiesContentArray OfEventSessionNextToolSuccessPropertiesContentArray]

func (*EventListResponseUnionPropertiesContent) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesContent) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesError 

type EventListResponseUnionPropertiesError struct {
	// This field is a union of [ProviderAuthErrorData], [UnknownErrorData],
	// [map[string]any], [MessageAbortedErrorData], [StructuredOutputErrorData],
	// [ContextOverflowErrorData], [APIErrorData]
	Data    EventListResponseUnionPropertiesErrorData `json:"data"`
	Name    string                                    `json:"name"`
	Message string                                    `json:"message"`
	// This field is from variant [SessionErrorUnknown].
	Type SessionErrorUnknownType `json:"type"`
	// This field is from variant [SessionNextRetryError].
	IsRetryable bool `json:"isRetryable"`
	// This field is from variant [SessionNextRetryError].
	Metadata map[string]string `json:"metadata"`
	// This field is from variant [SessionNextRetryError].
	ResponseBody string `json:"responseBody"`
	// This field is from variant [SessionNextRetryError].
	ResponseHeaders map[string]string `json:"responseHeaders"`
	// This field is from variant [SessionNextRetryError].
	StatusCode float64 `json:"statusCode"`
	JSON       struct {
		Data            respjson.Field
		Name            respjson.Field
		Message         respjson.Field
		Type            respjson.Field
		IsRetryable     respjson.Field
		Metadata        respjson.Field
		ResponseBody    respjson.Field
		ResponseHeaders respjson.Field
		StatusCode      respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesError is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesError provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesError) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesError) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesErrorData 

type EventListResponseUnionPropertiesErrorData struct {
	// This field will be present if the value is a [any] instead of an object.
	OfMessageOutputLengthErrorData any    `json:",inline"`
	Message                        string `json:"message"`
	// This field is from variant [ProviderAuthErrorData].
	ProviderID string `json:"providerID"`
	// This field is from variant [StructuredOutputErrorData].
	Retries      int64  `json:"retries"`
	ResponseBody string `json:"responseBody"`
	// This field is from variant [APIErrorData].
	IsRetryable bool `json:"isRetryable"`
	// This field is from variant [APIErrorData].
	Metadata map[string]string `json:"metadata"`
	// This field is from variant [APIErrorData].
	ResponseHeaders map[string]string `json:"responseHeaders"`
	// This field is from variant [APIErrorData].
	StatusCode int64 `json:"statusCode"`
	JSON       struct {
		OfMessageOutputLengthErrorData respjson.Field
		Message                        respjson.Field
		ProviderID                     respjson.Field
		Retries                        respjson.Field
		ResponseBody                   respjson.Field
		IsRetryable                    respjson.Field
		Metadata                       respjson.Field
		ResponseHeaders                respjson.Field
		StatusCode                     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesErrorData is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesErrorData provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfMessageOutputLengthErrorData]

func (*EventListResponseUnionPropertiesErrorData) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesErrorData) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesInfo 

type EventListResponseUnionPropertiesInfo struct {
	ID string `json:"id"`
	// This field is from variant [Pty].
	Args []string `json:"args"`
	// This field is from variant [Pty].
	Command string `json:"command"`
	// This field is from variant [Pty].
	Cwd string `json:"cwd"`
	// This field is from variant [Pty].
	Pid int64 `json:"pid"`
	// This field is from variant [Pty].
	Status PtyStatus `json:"status"`
	Title  string    `json:"title"`
	Agent  string    `json:"agent"`
	// This field is a union of [MessageUserMessageModel], [SessionModel]
	Model     EventListResponseUnionPropertiesInfoModel `json:"model"`
	Role      string                                    `json:"role"`
	SessionID string                                    `json:"sessionID"`
	// This field is a union of [MessageUserMessageTime], [AssistantMessageTime],
	// [SessionTime]
	Time EventListResponseUnionPropertiesInfoTime `json:"time"`
	// This field is from variant [MessageUnion].
	Format OutputFormatUnion `json:"format"`
	// This field is a union of [MessageUserMessageSummary], [bool], [SessionSummary]
	Summary EventListResponseUnionPropertiesInfoSummary `json:"summary"`
	// This field is from variant [MessageUnion].
	System string `json:"system"`
	// This field is from variant [MessageUnion].
	Tools map[string]bool `json:"tools"`
	Cost  float64         `json:"cost"`
	// This field is from variant [MessageUnion].
	Mode string `json:"mode"`
	// This field is from variant [MessageUnion].
	ModelID  string `json:"modelID"`
	ParentID string `json:"parentID"`
	// This field is a union of [AssistantMessagePath], [string]
	Path EventListResponseUnionPropertiesInfoPath `json:"path"`
	// This field is from variant [MessageUnion].
	ProviderID string `json:"providerID"`
	// This field is a union of [AssistantMessageTokens], [SessionTokens]
	Tokens EventListResponseUnionPropertiesInfoTokens `json:"tokens"`
	// This field is from variant [MessageUnion].
	Error AssistantMessageErrorUnion `json:"error"`
	// This field is from variant [MessageUnion].
	Finish string `json:"finish"`
	// This field is from variant [MessageUnion].
	Structured any `json:"structured"`
	// This field is from variant [MessageUnion].
	Variant string `json:"variant"`
	// This field is from variant [Session].
	Directory string `json:"directory"`
	// This field is from variant [Session].
	ProjectID string `json:"projectID"`
	// This field is from variant [Session].
	Slug string `json:"slug"`
	// This field is from variant [Session].
	Version string `json:"version"`
	// This field is from variant [Session].
	Permission []PermissionRule `json:"permission"`
	// This field is from variant [Session].
	Revert SessionRevert `json:"revert"`
	// This field is from variant [Session].
	Share SessionShare `json:"share"`
	// This field is from variant [Session].
	WorkspaceID string `json:"workspaceID"`
	JSON        struct {
		ID          respjson.Field
		Args        respjson.Field
		Command     respjson.Field
		Cwd         respjson.Field
		Pid         respjson.Field
		Status      respjson.Field
		Title       respjson.Field
		Agent       respjson.Field
		Model       respjson.Field
		Role        respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		Format      respjson.Field
		Summary     respjson.Field
		System      respjson.Field
		Tools       respjson.Field
		Cost        respjson.Field
		Mode        respjson.Field
		ModelID     respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		ProviderID  respjson.Field
		Tokens      respjson.Field
		Error       respjson.Field
		Finish      respjson.Field
		Structured  respjson.Field
		Variant     respjson.Field
		Directory   respjson.Field
		ProjectID   respjson.Field
		Slug        respjson.Field
		Version     respjson.Field
		Permission  respjson.Field
		Revert      respjson.Field
		Share       respjson.Field
		WorkspaceID respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesInfo is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesInfo provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesInfo) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesInfo) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesInfoModel 

type EventListResponseUnionPropertiesInfoModel struct {
	// This field is from variant [MessageUserMessageModel].
	ModelID    string `json:"modelID"`
	ProviderID string `json:"providerID"`
	Variant    string `json:"variant"`
	// This field is from variant [SessionModel].
	ID   string `json:"id"`
	JSON struct {
		ModelID    respjson.Field
		ProviderID respjson.Field
		Variant    respjson.Field
		ID         respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesInfoModel is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesInfoModel provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesInfoModel) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesInfoModel) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesInfoPath 

type EventListResponseUnionPropertiesInfoPath struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field is from variant [AssistantMessagePath].
	Cwd string `json:"cwd"`
	// This field is from variant [AssistantMessagePath].
	Root string `json:"root"`
	JSON struct {
		OfString respjson.Field
		Cwd      respjson.Field
		Root     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesInfoPath is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesInfoPath provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfString]

func (*EventListResponseUnionPropertiesInfoPath) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesInfoPath) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesInfoSummary 

type EventListResponseUnionPropertiesInfoSummary struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool bool               `json:",inline"`
	Diffs  []SnapshotFileDiff `json:"diffs"`
	// This field is from variant [MessageUserMessageSummary].
	Body string `json:"body"`
	// This field is from variant [MessageUserMessageSummary].
	Title string `json:"title"`
	// This field is from variant [SessionSummary].
	Additions float64 `json:"additions"`
	// This field is from variant [SessionSummary].
	Deletions float64 `json:"deletions"`
	// This field is from variant [SessionSummary].
	Files float64 `json:"files"`
	JSON  struct {
		OfBool    respjson.Field
		Diffs     respjson.Field
		Body      respjson.Field
		Title     respjson.Field
		Additions respjson.Field
		Deletions respjson.Field
		Files     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesInfoSummary is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesInfoSummary provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfBool]

func (*EventListResponseUnionPropertiesInfoSummary) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesInfoSummary) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesInfoTime 

type EventListResponseUnionPropertiesInfoTime struct {
	Created int64 `json:"created"`
	// This field is from variant [AssistantMessageTime].
	Completed int64 `json:"completed"`
	// This field is from variant [SessionTime].
	Updated int64 `json:"updated"`
	// This field is from variant [SessionTime].
	Archived float64 `json:"archived"`
	// This field is from variant [SessionTime].
	Compacting int64 `json:"compacting"`
	JSON       struct {
		Created    respjson.Field
		Completed  respjson.Field
		Updated    respjson.Field
		Archived   respjson.Field
		Compacting respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesInfoTime is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesInfoTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesInfoTime) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesInfoTime) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesInfoTokens 

type EventListResponseUnionPropertiesInfoTokens struct {
	// This field is a union of [AssistantMessageTokensCache], [SessionTokensCache]
	Cache     EventListResponseUnionPropertiesInfoTokensCache `json:"cache"`
	Input     float64                                         `json:"input"`
	Output    float64                                         `json:"output"`
	Reasoning float64                                         `json:"reasoning"`
	// This field is from variant [AssistantMessageTokens].
	Total float64 `json:"total"`
	JSON  struct {
		Cache     respjson.Field
		Input     respjson.Field
		Output    respjson.Field
		Reasoning respjson.Field
		Total     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesInfoTokens is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesInfoTokens provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesInfoTokens) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesInfoTokens) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesInfoTokensCache 

type EventListResponseUnionPropertiesInfoTokensCache struct {
	Read  float64 `json:"read"`
	Write float64 `json:"write"`
	JSON  struct {
		Read  respjson.Field
		Write respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesInfoTokensCache is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesInfoTokensCache provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesInfoTokensCache) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesInfoTokensCache) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesModel 

type EventListResponseUnionPropertiesModel struct {
	ID         string `json:"id"`
	ProviderID string `json:"providerID"`
	Variant    string `json:"variant"`
	// This field is from variant [ModelV2Info].
	APIID string `json:"apiID"`
	// This field is from variant [ModelV2Info].
	Capabilities ModelV2InfoCapabilities `json:"capabilities"`
	// This field is from variant [ModelV2Info].
	Cost []ModelV2InfoCost `json:"cost"`
	// This field is from variant [ModelV2Info].
	Enabled bool `json:"enabled"`
	// This field is from variant [ModelV2Info].
	Endpoint ModelV2InfoEndpointUnion `json:"endpoint"`
	// This field is from variant [ModelV2Info].
	Limit ModelV2InfoLimit `json:"limit"`
	// This field is from variant [ModelV2Info].
	Name string `json:"name"`
	// This field is from variant [ModelV2Info].
	Options ModelV2InfoOptions `json:"options"`
	// This field is from variant [ModelV2Info].
	Status ModelV2InfoStatus `json:"status"`
	// This field is from variant [ModelV2Info].
	Time ModelV2InfoTime `json:"time"`
	// This field is from variant [ModelV2Info].
	Variants []ModelV2InfoVariant `json:"variants"`
	// This field is from variant [ModelV2Info].
	Family string `json:"family"`
	JSON   struct {
		ID           respjson.Field
		ProviderID   respjson.Field
		Variant      respjson.Field
		APIID        respjson.Field
		Capabilities respjson.Field
		Cost         respjson.Field
		Enabled      respjson.Field
		Endpoint     respjson.Field
		Limit        respjson.Field
		Name         respjson.Field
		Options      respjson.Field
		Status       respjson.Field
		Time         respjson.Field
		Variants     respjson.Field
		Family       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesModel is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesModel provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesModel) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesModel) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesProvider 

type EventListResponseUnionPropertiesProvider struct {
	Executed bool `json:"executed"`
	Metadata any  `json:"metadata"`
	JSON     struct {
		Executed respjson.Field
		Metadata respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesProvider is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesProvider provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

func (*EventListResponseUnionPropertiesProvider) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesProvider) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesStatus 

type EventListResponseUnionPropertiesStatus struct {
	// This field will be present if the value is a [string] instead of an object.
	OfEventWorkspaceStatusPropertiesStatus string `json:",inline"`
	Type                                   string `json:"type"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Attempt int64 `json:"attempt"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Message string `json:"message"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Next int64 `json:"next"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Action EventSessionStatusPropertiesStatusObjectAction `json:"action"`
	JSON   struct {
		OfEventWorkspaceStatusPropertiesStatus respjson.Field
		Type                                   respjson.Field
		Attempt                                respjson.Field
		Message                                respjson.Field
		Next                                   respjson.Field
		Action                                 respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesStatus is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesStatus provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfEventWorkspaceStatusPropertiesStatus]

func (*EventListResponseUnionPropertiesStatus) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesStatus) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesTime 

type EventListResponseUnionPropertiesTime struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field is from variant [ProjectTime].
	Created int64 `json:"created"`
	// This field is from variant [ProjectTime].
	Updated int64 `json:"updated"`
	// This field is from variant [ProjectTime].
	Initialized int64 `json:"initialized"`
	JSON        struct {
		OfInt       respjson.Field
		Created     respjson.Field
		Updated     respjson.Field
		Initialized respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesTime is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfInt]

func (*EventListResponseUnionPropertiesTime) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesTime) UnmarshalJSON(data []byte) error

type EventListResponseUnionPropertiesTool 

type EventListResponseUnionPropertiesTool struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString  string `json:",inline"`
	CallID    string `json:"callID"`
	MessageID string `json:"messageID"`
	JSON      struct {
		OfString  respjson.Field
		CallID    respjson.Field
		MessageID respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventListResponseUnionPropertiesTool is an implicit subunion of EventListResponseUnion. EventListResponseUnionPropertiesTool provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventListResponseUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfString]

func (*EventListResponseUnionPropertiesTool) UnmarshalJSON 

func (r *EventListResponseUnionPropertiesTool) UnmarshalJSON(data []byte) error

type EventLspClientDiagnostics 

type EventLspClientDiagnostics struct {
	ID         string                              `json:"id" api:"required"`
	Properties EventLspClientDiagnosticsProperties `json:"properties" api:"required"`
	// Any of "lsp.client.diagnostics".
	Type EventLspClientDiagnosticsType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventLspClientDiagnostics) RawJSON 

func (r EventLspClientDiagnostics) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventLspClientDiagnostics) UnmarshalJSON 

func (r *EventLspClientDiagnostics) UnmarshalJSON(data []byte) error

type EventLspClientDiagnosticsProperties 

type EventLspClientDiagnosticsProperties struct {
	Path     string `json:"path" api:"required"`
	ServerID string `json:"serverID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Path        respjson.Field
		ServerID    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventLspClientDiagnosticsProperties) RawJSON 

func (r EventLspClientDiagnosticsProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventLspClientDiagnosticsProperties) UnmarshalJSON 

func (r *EventLspClientDiagnosticsProperties) UnmarshalJSON(data []byte) error

type EventLspClientDiagnosticsType 

type EventLspClientDiagnosticsType string
const (
	EventLspClientDiagnosticsTypeLspClientDiagnostics EventLspClientDiagnosticsType = "lsp.client.diagnostics"
)

type EventLspUpdated 

type EventLspUpdated struct {
	ID         string         `json:"id" api:"required"`
	Properties map[string]any `json:"properties" api:"required"`
	// Any of "lsp.updated".
	Type EventLspUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventLspUpdated) RawJSON 

func (r EventLspUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventLspUpdated) UnmarshalJSON 

func (r *EventLspUpdated) UnmarshalJSON(data []byte) error

type EventLspUpdatedType 

type EventLspUpdatedType string
const (
	EventLspUpdatedTypeLspUpdated EventLspUpdatedType = "lsp.updated"
)

type EventMcpBrowserOpenFailed 

type EventMcpBrowserOpenFailed struct {
	ID         string                              `json:"id" api:"required"`
	Properties EventMcpBrowserOpenFailedProperties `json:"properties" api:"required"`
	// Any of "mcp.browser.open.failed".
	Type EventMcpBrowserOpenFailedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMcpBrowserOpenFailed) RawJSON 

func (r EventMcpBrowserOpenFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMcpBrowserOpenFailed) UnmarshalJSON 

func (r *EventMcpBrowserOpenFailed) UnmarshalJSON(data []byte) error

type EventMcpBrowserOpenFailedProperties 

type EventMcpBrowserOpenFailedProperties struct {
	McpName string `json:"mcpName" api:"required"`
	URL     string `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		McpName     respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMcpBrowserOpenFailedProperties) RawJSON 

func (r EventMcpBrowserOpenFailedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMcpBrowserOpenFailedProperties) UnmarshalJSON 

func (r *EventMcpBrowserOpenFailedProperties) UnmarshalJSON(data []byte) error

type EventMcpBrowserOpenFailedType 

type EventMcpBrowserOpenFailedType string
const (
	EventMcpBrowserOpenFailedTypeMcpBrowserOpenFailed EventMcpBrowserOpenFailedType = "mcp.browser.open.failed"
)

type EventMcpToolsChanged 

type EventMcpToolsChanged struct {
	ID         string                         `json:"id" api:"required"`
	Properties EventMcpToolsChangedProperties `json:"properties" api:"required"`
	// Any of "mcp.tools.changed".
	Type EventMcpToolsChangedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMcpToolsChanged) RawJSON 

func (r EventMcpToolsChanged) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMcpToolsChanged) UnmarshalJSON 

func (r *EventMcpToolsChanged) UnmarshalJSON(data []byte) error

type EventMcpToolsChangedProperties 

type EventMcpToolsChangedProperties struct {
	Server string `json:"server" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Server      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMcpToolsChangedProperties) RawJSON 

func (r EventMcpToolsChangedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMcpToolsChangedProperties) UnmarshalJSON 

func (r *EventMcpToolsChangedProperties) UnmarshalJSON(data []byte) error

type EventMcpToolsChangedType 

type EventMcpToolsChangedType string
const (
	EventMcpToolsChangedTypeMcpToolsChanged EventMcpToolsChangedType = "mcp.tools.changed"
)

type EventMessagePartDelta 

type EventMessagePartDelta struct {
	ID         string                          `json:"id" api:"required"`
	Properties EventMessagePartDeltaProperties `json:"properties" api:"required"`
	// Any of "message.part.delta".
	Type EventMessagePartDeltaType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessagePartDelta) RawJSON 

func (r EventMessagePartDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessagePartDelta) UnmarshalJSON 

func (r *EventMessagePartDelta) UnmarshalJSON(data []byte) error

type EventMessagePartDeltaProperties 

type EventMessagePartDeltaProperties struct {
	Delta     string `json:"delta" api:"required"`
	Field     string `json:"field" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	PartID    string `json:"partID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Delta       respjson.Field
		Field       respjson.Field
		MessageID   respjson.Field
		PartID      respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessagePartDeltaProperties) RawJSON 

func (r EventMessagePartDeltaProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessagePartDeltaProperties) UnmarshalJSON 

func (r *EventMessagePartDeltaProperties) UnmarshalJSON(data []byte) error

type EventMessagePartDeltaType 

type EventMessagePartDeltaType string
const (
	EventMessagePartDeltaTypeMessagePartDelta EventMessagePartDeltaType = "message.part.delta"
)

type EventMessagePartRemoved 

type EventMessagePartRemoved struct {
	ID         string                            `json:"id" api:"required"`
	Properties EventMessagePartRemovedProperties `json:"properties" api:"required"`
	// Any of "message.part.removed".
	Type EventMessagePartRemovedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessagePartRemoved) RawJSON 

func (r EventMessagePartRemoved) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessagePartRemoved) UnmarshalJSON 

func (r *EventMessagePartRemoved) UnmarshalJSON(data []byte) error

type EventMessagePartRemovedProperties 

type EventMessagePartRemovedProperties struct {
	MessageID string `json:"messageID" api:"required"`
	PartID    string `json:"partID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MessageID   respjson.Field
		PartID      respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessagePartRemovedProperties) RawJSON 

func (r EventMessagePartRemovedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessagePartRemovedProperties) UnmarshalJSON 

func (r *EventMessagePartRemovedProperties) UnmarshalJSON(data []byte) error

type EventMessagePartRemovedType 

type EventMessagePartRemovedType string
const (
	EventMessagePartRemovedTypeMessagePartRemoved EventMessagePartRemovedType = "message.part.removed"
)

type EventMessagePartUpdated 

type EventMessagePartUpdated struct {
	ID         string                            `json:"id" api:"required"`
	Properties EventMessagePartUpdatedProperties `json:"properties" api:"required"`
	// Any of "message.part.updated".
	Type EventMessagePartUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessagePartUpdated) RawJSON 

func (r EventMessagePartUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessagePartUpdated) UnmarshalJSON 

func (r *EventMessagePartUpdated) UnmarshalJSON(data []byte) error

type EventMessagePartUpdatedProperties 

type EventMessagePartUpdatedProperties struct {
	Part      PartUnion `json:"part" api:"required"`
	SessionID string    `json:"sessionID" api:"required"`
	Time      int64     `json:"time" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Part        respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessagePartUpdatedProperties) RawJSON 

func (r EventMessagePartUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessagePartUpdatedProperties) UnmarshalJSON 

func (r *EventMessagePartUpdatedProperties) UnmarshalJSON(data []byte) error

type EventMessagePartUpdatedType 

type EventMessagePartUpdatedType string
const (
	EventMessagePartUpdatedTypeMessagePartUpdated EventMessagePartUpdatedType = "message.part.updated"
)

type EventMessageRemoved 

type EventMessageRemoved struct {
	ID         string                        `json:"id" api:"required"`
	Properties EventMessageRemovedProperties `json:"properties" api:"required"`
	// Any of "message.removed".
	Type EventMessageRemovedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessageRemoved) RawJSON 

func (r EventMessageRemoved) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessageRemoved) UnmarshalJSON 

func (r *EventMessageRemoved) UnmarshalJSON(data []byte) error

type EventMessageRemovedProperties 

type EventMessageRemovedProperties struct {
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MessageID   respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessageRemovedProperties) RawJSON 

func (r EventMessageRemovedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessageRemovedProperties) UnmarshalJSON 

func (r *EventMessageRemovedProperties) UnmarshalJSON(data []byte) error

type EventMessageRemovedType 

type EventMessageRemovedType string
const (
	EventMessageRemovedTypeMessageRemoved EventMessageRemovedType = "message.removed"
)

type EventMessageUpdated 

type EventMessageUpdated struct {
	ID         string                        `json:"id" api:"required"`
	Properties EventMessageUpdatedProperties `json:"properties" api:"required"`
	// Any of "message.updated".
	Type EventMessageUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessageUpdated) RawJSON 

func (r EventMessageUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessageUpdated) UnmarshalJSON 

func (r *EventMessageUpdated) UnmarshalJSON(data []byte) error

type EventMessageUpdatedProperties 

type EventMessageUpdatedProperties struct {
	Info      MessageUnion `json:"info" api:"required"`
	SessionID string       `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventMessageUpdatedProperties) RawJSON 

func (r EventMessageUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventMessageUpdatedProperties) UnmarshalJSON 

func (r *EventMessageUpdatedProperties) UnmarshalJSON(data []byte) error

type EventMessageUpdatedType 

type EventMessageUpdatedType string
const (
	EventMessageUpdatedTypeMessageUpdated EventMessageUpdatedType = "message.updated"
)

type EventPermissionAsked 

type EventPermissionAsked struct {
	ID         string            `json:"id" api:"required"`
	Properties PermissionRequest `json:"properties" api:"required"`
	// Any of "permission.asked".
	Type EventPermissionAskedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPermissionAsked) RawJSON 

func (r EventPermissionAsked) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPermissionAsked) UnmarshalJSON 

func (r *EventPermissionAsked) UnmarshalJSON(data []byte) error

type EventPermissionAskedType 

type EventPermissionAskedType string
const (
	EventPermissionAskedTypePermissionAsked EventPermissionAskedType = "permission.asked"
)

type EventPermissionReplied 

type EventPermissionReplied struct {
	ID         string                           `json:"id" api:"required"`
	Properties EventPermissionRepliedProperties `json:"properties" api:"required"`
	// Any of "permission.replied".
	Type EventPermissionRepliedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPermissionReplied) RawJSON 

func (r EventPermissionReplied) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPermissionReplied) UnmarshalJSON 

func (r *EventPermissionReplied) UnmarshalJSON(data []byte) error

type EventPermissionRepliedProperties 

type EventPermissionRepliedProperties struct {
	// Any of "once", "always", "reject".
	Reply     string `json:"reply" api:"required"`
	RequestID string `json:"requestID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Reply       respjson.Field
		RequestID   respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPermissionRepliedProperties) RawJSON 

func (r EventPermissionRepliedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPermissionRepliedProperties) UnmarshalJSON 

func (r *EventPermissionRepliedProperties) UnmarshalJSON(data []byte) error

type EventPermissionRepliedType 

type EventPermissionRepliedType string
const (
	EventPermissionRepliedTypePermissionReplied EventPermissionRepliedType = "permission.replied"
)

type EventProjectUpdated 

type EventProjectUpdated struct {
	ID         string  `json:"id" api:"required"`
	Properties Project `json:"properties" api:"required"`
	// Any of "project.updated".
	Type EventProjectUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventProjectUpdated) RawJSON 

func (r EventProjectUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventProjectUpdated) UnmarshalJSON 

func (r *EventProjectUpdated) UnmarshalJSON(data []byte) error

type EventProjectUpdatedType 

type EventProjectUpdatedType string
const (
	EventProjectUpdatedTypeProjectUpdated EventProjectUpdatedType = "project.updated"
)

type EventPtyCreated 

type EventPtyCreated struct {
	ID         string                    `json:"id" api:"required"`
	Properties EventPtyCreatedProperties `json:"properties" api:"required"`
	// Any of "pty.created".
	Type EventPtyCreatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyCreated) RawJSON 

func (r EventPtyCreated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyCreated) UnmarshalJSON 

func (r *EventPtyCreated) UnmarshalJSON(data []byte) error

type EventPtyCreatedProperties 

type EventPtyCreatedProperties struct {
	Info Pty `json:"info" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyCreatedProperties) RawJSON 

func (r EventPtyCreatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyCreatedProperties) UnmarshalJSON 

func (r *EventPtyCreatedProperties) UnmarshalJSON(data []byte) error

type EventPtyCreatedType 

type EventPtyCreatedType string
const (
	EventPtyCreatedTypePtyCreated EventPtyCreatedType = "pty.created"
)

type EventPtyDeleted 

type EventPtyDeleted struct {
	ID         string                    `json:"id" api:"required"`
	Properties EventPtyDeletedProperties `json:"properties" api:"required"`
	// Any of "pty.deleted".
	Type EventPtyDeletedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyDeleted) RawJSON 

func (r EventPtyDeleted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyDeleted) UnmarshalJSON 

func (r *EventPtyDeleted) UnmarshalJSON(data []byte) error

type EventPtyDeletedProperties 

type EventPtyDeletedProperties struct {
	ID string `json:"id" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyDeletedProperties) RawJSON 

func (r EventPtyDeletedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyDeletedProperties) UnmarshalJSON 

func (r *EventPtyDeletedProperties) UnmarshalJSON(data []byte) error

type EventPtyDeletedType 

type EventPtyDeletedType string
const (
	EventPtyDeletedTypePtyDeleted EventPtyDeletedType = "pty.deleted"
)

type EventPtyExited 

type EventPtyExited struct {
	ID         string                   `json:"id" api:"required"`
	Properties EventPtyExitedProperties `json:"properties" api:"required"`
	// Any of "pty.exited".
	Type EventPtyExitedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyExited) RawJSON 

func (r EventPtyExited) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyExited) UnmarshalJSON 

func (r *EventPtyExited) UnmarshalJSON(data []byte) error

type EventPtyExitedProperties 

type EventPtyExitedProperties struct {
	ID       string `json:"id" api:"required"`
	ExitCode int64  `json:"exitCode" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExitCode    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyExitedProperties) RawJSON 

func (r EventPtyExitedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyExitedProperties) UnmarshalJSON 

func (r *EventPtyExitedProperties) UnmarshalJSON(data []byte) error

type EventPtyExitedType 

type EventPtyExitedType string
const (
	EventPtyExitedTypePtyExited EventPtyExitedType = "pty.exited"
)

type EventPtyUpdated 

type EventPtyUpdated struct {
	ID         string                    `json:"id" api:"required"`
	Properties EventPtyUpdatedProperties `json:"properties" api:"required"`
	// Any of "pty.updated".
	Type EventPtyUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyUpdated) RawJSON 

func (r EventPtyUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyUpdated) UnmarshalJSON 

func (r *EventPtyUpdated) UnmarshalJSON(data []byte) error

type EventPtyUpdatedProperties 

type EventPtyUpdatedProperties struct {
	Info Pty `json:"info" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventPtyUpdatedProperties) RawJSON 

func (r EventPtyUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventPtyUpdatedProperties) UnmarshalJSON 

func (r *EventPtyUpdatedProperties) UnmarshalJSON(data []byte) error

type EventPtyUpdatedType 

type EventPtyUpdatedType string
const (
	EventPtyUpdatedTypePtyUpdated EventPtyUpdatedType = "pty.updated"
)

type EventQuestionAsked 

type EventQuestionAsked struct {
	ID         string          `json:"id" api:"required"`
	Properties QuestionRequest `json:"properties" api:"required"`
	// Any of "question.asked".
	Type EventQuestionAskedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventQuestionAsked) RawJSON 

func (r EventQuestionAsked) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventQuestionAsked) UnmarshalJSON 

func (r *EventQuestionAsked) UnmarshalJSON(data []byte) error

type EventQuestionAskedType 

type EventQuestionAskedType string
const (
	EventQuestionAskedTypeQuestionAsked EventQuestionAskedType = "question.asked"
)

type EventQuestionRejected 

type EventQuestionRejected struct {
	ID         string                          `json:"id" api:"required"`
	Properties EventQuestionRejectedProperties `json:"properties" api:"required"`
	// Any of "question.rejected".
	Type EventQuestionRejectedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventQuestionRejected) RawJSON 

func (r EventQuestionRejected) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventQuestionRejected) UnmarshalJSON 

func (r *EventQuestionRejected) UnmarshalJSON(data []byte) error

type EventQuestionRejectedProperties 

type EventQuestionRejectedProperties struct {
	RequestID string `json:"requestID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		RequestID   respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventQuestionRejectedProperties) RawJSON 

func (r EventQuestionRejectedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventQuestionRejectedProperties) UnmarshalJSON 

func (r *EventQuestionRejectedProperties) UnmarshalJSON(data []byte) error

type EventQuestionRejectedType 

type EventQuestionRejectedType string
const (
	EventQuestionRejectedTypeQuestionRejected EventQuestionRejectedType = "question.rejected"
)

type EventQuestionReplied 

type EventQuestionReplied struct {
	ID         string                         `json:"id" api:"required"`
	Properties EventQuestionRepliedProperties `json:"properties" api:"required"`
	// Any of "question.replied".
	Type EventQuestionRepliedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventQuestionReplied) RawJSON 

func (r EventQuestionReplied) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventQuestionReplied) UnmarshalJSON 

func (r *EventQuestionReplied) UnmarshalJSON(data []byte) error

type EventQuestionRepliedProperties 

type EventQuestionRepliedProperties struct {
	Answers   [][]string `json:"answers" api:"required"`
	RequestID string     `json:"requestID" api:"required"`
	SessionID string     `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Answers     respjson.Field
		RequestID   respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventQuestionRepliedProperties) RawJSON 

func (r EventQuestionRepliedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventQuestionRepliedProperties) UnmarshalJSON 

func (r *EventQuestionRepliedProperties) UnmarshalJSON(data []byte) error

type EventQuestionRepliedType 

type EventQuestionRepliedType string
const (
	EventQuestionRepliedTypeQuestionReplied EventQuestionRepliedType = "question.replied"
)

type EventServerConnected 

type EventServerConnected struct {
	ID         string         `json:"id" api:"required"`
	Properties map[string]any `json:"properties" api:"required"`
	// Any of "server.connected".
	Type EventServerConnectedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventServerConnected) RawJSON 

func (r EventServerConnected) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventServerConnected) UnmarshalJSON 

func (r *EventServerConnected) UnmarshalJSON(data []byte) error

type EventServerConnectedType 

type EventServerConnectedType string
const (
	EventServerConnectedTypeServerConnected EventServerConnectedType = "server.connected"
)

type EventServerInstanceDisposed 

type EventServerInstanceDisposed struct {
	ID         string                                `json:"id" api:"required"`
	Properties EventServerInstanceDisposedProperties `json:"properties" api:"required"`
	// Any of "server.instance.disposed".
	Type EventServerInstanceDisposedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventServerInstanceDisposed) RawJSON 

func (r EventServerInstanceDisposed) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventServerInstanceDisposed) UnmarshalJSON 

func (r *EventServerInstanceDisposed) UnmarshalJSON(data []byte) error

type EventServerInstanceDisposedProperties 

type EventServerInstanceDisposedProperties struct {
	Directory string `json:"directory" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Directory   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventServerInstanceDisposedProperties) RawJSON 

func (r EventServerInstanceDisposedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventServerInstanceDisposedProperties) UnmarshalJSON 

func (r *EventServerInstanceDisposedProperties) UnmarshalJSON(data []byte) error

type EventServerInstanceDisposedType 

type EventServerInstanceDisposedType string
const (
	EventServerInstanceDisposedTypeServerInstanceDisposed EventServerInstanceDisposedType = "server.instance.disposed"
)

type EventService 

type EventService struct {
	// contains filtered or unexported fields
}

Instance event stream route.

EventService contains methods and other services that help with interacting with the opencode-stainless 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 NewEventService method instead.

func NewEventService 

func NewEventService(opts ...option.RequestOption) (r EventService)

NewEventService 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 (*EventService) ListStreaming 

func (r *EventService) ListStreaming(ctx context.Context, query EventListParams, opts ...option.RequestOption) (stream *ssestream.Stream[EventListResponseUnion])

Get events

type EventSessionCompacted 

type EventSessionCompacted struct {
	ID         string                          `json:"id" api:"required"`
	Properties EventSessionCompactedProperties `json:"properties" api:"required"`
	// Any of "session.compacted".
	Type EventSessionCompactedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionCompacted) RawJSON 

func (r EventSessionCompacted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionCompacted) UnmarshalJSON 

func (r *EventSessionCompacted) UnmarshalJSON(data []byte) error

type EventSessionCompactedProperties 

type EventSessionCompactedProperties struct {
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionCompactedProperties) RawJSON 

func (r EventSessionCompactedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionCompactedProperties) UnmarshalJSON 

func (r *EventSessionCompactedProperties) UnmarshalJSON(data []byte) error

type EventSessionCompactedType 

type EventSessionCompactedType string
const (
	EventSessionCompactedTypeSessionCompacted EventSessionCompactedType = "session.compacted"
)

type EventSessionCreated 

type EventSessionCreated struct {
	ID         string                        `json:"id" api:"required"`
	Properties EventSessionCreatedProperties `json:"properties" api:"required"`
	// Any of "session.created".
	Type EventSessionCreatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionCreated) RawJSON 

func (r EventSessionCreated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionCreated) UnmarshalJSON 

func (r *EventSessionCreated) UnmarshalJSON(data []byte) error

type EventSessionCreatedProperties 

type EventSessionCreatedProperties struct {
	Info      Session `json:"info" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionCreatedProperties) RawJSON 

func (r EventSessionCreatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionCreatedProperties) UnmarshalJSON 

func (r *EventSessionCreatedProperties) UnmarshalJSON(data []byte) error

type EventSessionCreatedType 

type EventSessionCreatedType string
const (
	EventSessionCreatedTypeSessionCreated EventSessionCreatedType = "session.created"
)

type EventSessionDeleted 

type EventSessionDeleted struct {
	ID         string                        `json:"id" api:"required"`
	Properties EventSessionDeletedProperties `json:"properties" api:"required"`
	// Any of "session.deleted".
	Type EventSessionDeletedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionDeleted) RawJSON 

func (r EventSessionDeleted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionDeleted) UnmarshalJSON 

func (r *EventSessionDeleted) UnmarshalJSON(data []byte) error

type EventSessionDeletedProperties 

type EventSessionDeletedProperties struct {
	Info      Session `json:"info" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionDeletedProperties) RawJSON 

func (r EventSessionDeletedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionDeletedProperties) UnmarshalJSON 

func (r *EventSessionDeletedProperties) UnmarshalJSON(data []byte) error

type EventSessionDeletedType 

type EventSessionDeletedType string
const (
	EventSessionDeletedTypeSessionDeleted EventSessionDeletedType = "session.deleted"
)

type EventSessionDiff 

type EventSessionDiff struct {
	ID         string                     `json:"id" api:"required"`
	Properties EventSessionDiffProperties `json:"properties" api:"required"`
	// Any of "session.diff".
	Type EventSessionDiffType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionDiff) RawJSON 

func (r EventSessionDiff) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionDiff) UnmarshalJSON 

func (r *EventSessionDiff) UnmarshalJSON(data []byte) error

type EventSessionDiffProperties 

type EventSessionDiffProperties struct {
	Diff      []SnapshotFileDiff `json:"diff" api:"required"`
	SessionID string             `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Diff        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionDiffProperties) RawJSON 

func (r EventSessionDiffProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionDiffProperties) UnmarshalJSON 

func (r *EventSessionDiffProperties) UnmarshalJSON(data []byte) error

type EventSessionDiffType 

type EventSessionDiffType string
const (
	EventSessionDiffTypeSessionDiff EventSessionDiffType = "session.diff"
)

type EventSessionError 

type EventSessionError struct {
	ID         string                      `json:"id" api:"required"`
	Properties EventSessionErrorProperties `json:"properties" api:"required"`
	// Any of "session.error".
	Type EventSessionErrorType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionError) RawJSON 

func (r EventSessionError) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionError) UnmarshalJSON 

func (r *EventSessionError) UnmarshalJSON(data []byte) error

type EventSessionErrorProperties 

type EventSessionErrorProperties struct {
	Error     EventSessionErrorPropertiesErrorUnion `json:"error"`
	SessionID string                                `json:"sessionID"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionErrorProperties) RawJSON 

func (r EventSessionErrorProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionErrorProperties) UnmarshalJSON 

func (r *EventSessionErrorProperties) UnmarshalJSON(data []byte) error

type EventSessionErrorPropertiesErrorUnion 

type EventSessionErrorPropertiesErrorUnion struct {
	// This field is a union of [ProviderAuthErrorData], [UnknownErrorData],
	// [map[string]any], [MessageAbortedErrorData], [StructuredOutputErrorData],
	// [ContextOverflowErrorData], [APIErrorData]
	Data EventSessionErrorPropertiesErrorUnionData `json:"data"`
	Name string                                    `json:"name"`
	JSON struct {
		Data respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventSessionErrorPropertiesErrorUnion contains all possible properties and values from ProviderAuthError, UnknownError, MessageOutputLengthError, MessageAbortedError, StructuredOutputError, ContextOverflowError, APIError.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (EventSessionErrorPropertiesErrorUnion) AsAPIError 

func (u EventSessionErrorPropertiesErrorUnion) AsAPIError() (v APIError)

func (EventSessionErrorPropertiesErrorUnion) AsContextOverflowError 

func (u EventSessionErrorPropertiesErrorUnion) AsContextOverflowError() (v ContextOverflowError)

func (EventSessionErrorPropertiesErrorUnion) AsMessageAbortedError 

func (u EventSessionErrorPropertiesErrorUnion) AsMessageAbortedError() (v MessageAbortedError)

func (EventSessionErrorPropertiesErrorUnion) AsMessageOutputLengthError 

func (u EventSessionErrorPropertiesErrorUnion) AsMessageOutputLengthError() (v MessageOutputLengthError)

func (EventSessionErrorPropertiesErrorUnion) AsProviderAuthError 

func (u EventSessionErrorPropertiesErrorUnion) AsProviderAuthError() (v ProviderAuthError)

func (EventSessionErrorPropertiesErrorUnion) AsStructuredOutputError 

func (u EventSessionErrorPropertiesErrorUnion) AsStructuredOutputError() (v StructuredOutputError)

func (EventSessionErrorPropertiesErrorUnion) AsUnknownError 

func (u EventSessionErrorPropertiesErrorUnion) AsUnknownError() (v UnknownError)

func (EventSessionErrorPropertiesErrorUnion) RawJSON 

func (u EventSessionErrorPropertiesErrorUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionErrorPropertiesErrorUnion) UnmarshalJSON 

func (r *EventSessionErrorPropertiesErrorUnion) UnmarshalJSON(data []byte) error

type EventSessionErrorPropertiesErrorUnionData 

type EventSessionErrorPropertiesErrorUnionData struct {
	// This field will be present if the value is a [any] instead of an object.
	OfMessageOutputLengthErrorData any    `json:",inline"`
	Message                        string `json:"message"`
	// This field is from variant [ProviderAuthErrorData].
	ProviderID string `json:"providerID"`
	// This field is from variant [StructuredOutputErrorData].
	Retries      int64  `json:"retries"`
	ResponseBody string `json:"responseBody"`
	// This field is from variant [APIErrorData].
	IsRetryable bool `json:"isRetryable"`
	// This field is from variant [APIErrorData].
	Metadata map[string]string `json:"metadata"`
	// This field is from variant [APIErrorData].
	ResponseHeaders map[string]string `json:"responseHeaders"`
	// This field is from variant [APIErrorData].
	StatusCode int64 `json:"statusCode"`
	JSON       struct {
		OfMessageOutputLengthErrorData respjson.Field
		Message                        respjson.Field
		ProviderID                     respjson.Field
		Retries                        respjson.Field
		ResponseBody                   respjson.Field
		IsRetryable                    respjson.Field
		Metadata                       respjson.Field
		ResponseHeaders                respjson.Field
		StatusCode                     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventSessionErrorPropertiesErrorUnionData is an implicit subunion of EventSessionErrorPropertiesErrorUnion. EventSessionErrorPropertiesErrorUnionData provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the EventSessionErrorPropertiesErrorUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfMessageOutputLengthErrorData]

func (*EventSessionErrorPropertiesErrorUnionData) UnmarshalJSON 

func (r *EventSessionErrorPropertiesErrorUnionData) UnmarshalJSON(data []byte) error

type EventSessionErrorType 

type EventSessionErrorType string
const (
	EventSessionErrorTypeSessionError EventSessionErrorType = "session.error"
)

type EventSessionIdle 

type EventSessionIdle struct {
	ID         string                     `json:"id" api:"required"`
	Properties EventSessionIdleProperties `json:"properties" api:"required"`
	// Any of "session.idle".
	Type EventSessionIdleType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionIdle) RawJSON 

func (r EventSessionIdle) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionIdle) UnmarshalJSON 

func (r *EventSessionIdle) UnmarshalJSON(data []byte) error

type EventSessionIdleProperties 

type EventSessionIdleProperties struct {
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionIdleProperties) RawJSON 

func (r EventSessionIdleProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionIdleProperties) UnmarshalJSON 

func (r *EventSessionIdleProperties) UnmarshalJSON(data []byte) error

type EventSessionIdleType 

type EventSessionIdleType string
const (
	EventSessionIdleTypeSessionIdle EventSessionIdleType = "session.idle"
)

type EventSessionNextAgentSwitched 

type EventSessionNextAgentSwitched struct {
	ID         string                                  `json:"id" api:"required"`
	Properties EventSessionNextAgentSwitchedProperties `json:"properties" api:"required"`
	// Any of "session.next.agent.switched".
	Type EventSessionNextAgentSwitchedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextAgentSwitched) RawJSON 

func (r EventSessionNextAgentSwitched) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextAgentSwitched) UnmarshalJSON 

func (r *EventSessionNextAgentSwitched) UnmarshalJSON(data []byte) error

type EventSessionNextAgentSwitchedProperties 

type EventSessionNextAgentSwitchedProperties struct {
	Agent     string  `json:"agent" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Agent       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextAgentSwitchedProperties) RawJSON 

func (r EventSessionNextAgentSwitchedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextAgentSwitchedProperties) UnmarshalJSON 

func (r *EventSessionNextAgentSwitchedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextAgentSwitchedType 

type EventSessionNextAgentSwitchedType string
const (
	EventSessionNextAgentSwitchedTypeSessionNextAgentSwitched EventSessionNextAgentSwitchedType = "session.next.agent.switched"
)

type EventSessionNextCompactionDelta 

type EventSessionNextCompactionDelta struct {
	ID         string                                    `json:"id" api:"required"`
	Properties EventSessionNextCompactionDeltaProperties `json:"properties" api:"required"`
	// Any of "session.next.compaction.delta".
	Type EventSessionNextCompactionDeltaType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextCompactionDelta) RawJSON 

func (r EventSessionNextCompactionDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextCompactionDelta) UnmarshalJSON 

func (r *EventSessionNextCompactionDelta) UnmarshalJSON(data []byte) error

type EventSessionNextCompactionDeltaProperties 

type EventSessionNextCompactionDeltaProperties struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextCompactionDeltaProperties) RawJSON 

func (r EventSessionNextCompactionDeltaProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextCompactionDeltaProperties) UnmarshalJSON 

func (r *EventSessionNextCompactionDeltaProperties) UnmarshalJSON(data []byte) error

type EventSessionNextCompactionDeltaType 

type EventSessionNextCompactionDeltaType string
const (
	EventSessionNextCompactionDeltaTypeSessionNextCompactionDelta EventSessionNextCompactionDeltaType = "session.next.compaction.delta"
)

type EventSessionNextCompactionEnded 

type EventSessionNextCompactionEnded struct {
	ID         string                                    `json:"id" api:"required"`
	Properties EventSessionNextCompactionEndedProperties `json:"properties" api:"required"`
	// Any of "session.next.compaction.ended".
	Type EventSessionNextCompactionEndedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextCompactionEnded) RawJSON 

func (r EventSessionNextCompactionEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextCompactionEnded) UnmarshalJSON 

func (r *EventSessionNextCompactionEnded) UnmarshalJSON(data []byte) error

type EventSessionNextCompactionEndedProperties 

type EventSessionNextCompactionEndedProperties struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	Include   string  `json:"include"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		Include     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextCompactionEndedProperties) RawJSON 

func (r EventSessionNextCompactionEndedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextCompactionEndedProperties) UnmarshalJSON 

func (r *EventSessionNextCompactionEndedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextCompactionEndedType 

type EventSessionNextCompactionEndedType string
const (
	EventSessionNextCompactionEndedTypeSessionNextCompactionEnded EventSessionNextCompactionEndedType = "session.next.compaction.ended"
)

type EventSessionNextCompactionStarted 

type EventSessionNextCompactionStarted struct {
	ID         string                                      `json:"id" api:"required"`
	Properties EventSessionNextCompactionStartedProperties `json:"properties" api:"required"`
	// Any of "session.next.compaction.started".
	Type EventSessionNextCompactionStartedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextCompactionStarted) RawJSON 

func (r EventSessionNextCompactionStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextCompactionStarted) UnmarshalJSON 

func (r *EventSessionNextCompactionStarted) UnmarshalJSON(data []byte) error

type EventSessionNextCompactionStartedProperties 

type EventSessionNextCompactionStartedProperties struct {
	// Any of "auto", "manual".
	Reason    string  `json:"reason" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Reason      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextCompactionStartedProperties) RawJSON 

func (r EventSessionNextCompactionStartedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextCompactionStartedProperties) UnmarshalJSON 

func (r *EventSessionNextCompactionStartedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextCompactionStartedType 

type EventSessionNextCompactionStartedType string
const (
	EventSessionNextCompactionStartedTypeSessionNextCompactionStarted EventSessionNextCompactionStartedType = "session.next.compaction.started"
)

type EventSessionNextModelSwitched 

type EventSessionNextModelSwitched struct {
	ID         string                                  `json:"id" api:"required"`
	Properties EventSessionNextModelSwitchedProperties `json:"properties" api:"required"`
	// Any of "session.next.model.switched".
	Type EventSessionNextModelSwitchedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextModelSwitched) RawJSON 

func (r EventSessionNextModelSwitched) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextModelSwitched) UnmarshalJSON 

func (r *EventSessionNextModelSwitched) UnmarshalJSON(data []byte) error

type EventSessionNextModelSwitchedProperties 

type EventSessionNextModelSwitchedProperties struct {
	Model     EventSessionNextModelSwitchedPropertiesModel `json:"model" api:"required"`
	SessionID string                                       `json:"sessionID" api:"required"`
	Timestamp float64                                      `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Model       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextModelSwitchedProperties) RawJSON 

func (r EventSessionNextModelSwitchedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextModelSwitchedProperties) UnmarshalJSON 

func (r *EventSessionNextModelSwitchedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextModelSwitchedPropertiesModel 

type EventSessionNextModelSwitchedPropertiesModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextModelSwitchedPropertiesModel) RawJSON 

func (r EventSessionNextModelSwitchedPropertiesModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextModelSwitchedPropertiesModel) UnmarshalJSON 

func (r *EventSessionNextModelSwitchedPropertiesModel) UnmarshalJSON(data []byte) error

type EventSessionNextModelSwitchedType 

type EventSessionNextModelSwitchedType string
const (
	EventSessionNextModelSwitchedTypeSessionNextModelSwitched EventSessionNextModelSwitchedType = "session.next.model.switched"
)

type EventSessionNextPrompted 

type EventSessionNextPrompted struct {
	ID         string                             `json:"id" api:"required"`
	Properties EventSessionNextPromptedProperties `json:"properties" api:"required"`
	// Any of "session.next.prompted".
	Type EventSessionNextPromptedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextPrompted) RawJSON 

func (r EventSessionNextPrompted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextPrompted) UnmarshalJSON 

func (r *EventSessionNextPrompted) UnmarshalJSON(data []byte) error

type EventSessionNextPromptedProperties 

type EventSessionNextPromptedProperties struct {
	Prompt    Prompt  `json:"prompt" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Prompt      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextPromptedProperties) RawJSON 

func (r EventSessionNextPromptedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextPromptedProperties) UnmarshalJSON 

func (r *EventSessionNextPromptedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextPromptedType 

type EventSessionNextPromptedType string
const (
	EventSessionNextPromptedTypeSessionNextPrompted EventSessionNextPromptedType = "session.next.prompted"
)

type EventSessionNextReasoningDelta 

type EventSessionNextReasoningDelta struct {
	ID         string                                   `json:"id" api:"required"`
	Properties EventSessionNextReasoningDeltaProperties `json:"properties" api:"required"`
	// Any of "session.next.reasoning.delta".
	Type EventSessionNextReasoningDeltaType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextReasoningDelta) RawJSON 

func (r EventSessionNextReasoningDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextReasoningDelta) UnmarshalJSON 

func (r *EventSessionNextReasoningDelta) UnmarshalJSON(data []byte) error

type EventSessionNextReasoningDeltaProperties 

type EventSessionNextReasoningDeltaProperties struct {
	Delta       string  `json:"delta" api:"required"`
	ReasoningID string  `json:"reasoningID" api:"required"`
	SessionID   string  `json:"sessionID" api:"required"`
	Timestamp   float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Delta       respjson.Field
		ReasoningID respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextReasoningDeltaProperties) RawJSON 

func (r EventSessionNextReasoningDeltaProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextReasoningDeltaProperties) UnmarshalJSON 

func (r *EventSessionNextReasoningDeltaProperties) UnmarshalJSON(data []byte) error

type EventSessionNextReasoningDeltaType 

type EventSessionNextReasoningDeltaType string
const (
	EventSessionNextReasoningDeltaTypeSessionNextReasoningDelta EventSessionNextReasoningDeltaType = "session.next.reasoning.delta"
)

type EventSessionNextReasoningEnded 

type EventSessionNextReasoningEnded struct {
	ID         string                                   `json:"id" api:"required"`
	Properties EventSessionNextReasoningEndedProperties `json:"properties" api:"required"`
	// Any of "session.next.reasoning.ended".
	Type EventSessionNextReasoningEndedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextReasoningEnded) RawJSON 

func (r EventSessionNextReasoningEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextReasoningEnded) UnmarshalJSON 

func (r *EventSessionNextReasoningEnded) UnmarshalJSON(data []byte) error

type EventSessionNextReasoningEndedProperties 

type EventSessionNextReasoningEndedProperties struct {
	ReasoningID string  `json:"reasoningID" api:"required"`
	SessionID   string  `json:"sessionID" api:"required"`
	Text        string  `json:"text" api:"required"`
	Timestamp   float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ReasoningID respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextReasoningEndedProperties) RawJSON 

func (r EventSessionNextReasoningEndedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextReasoningEndedProperties) UnmarshalJSON 

func (r *EventSessionNextReasoningEndedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextReasoningEndedType 

type EventSessionNextReasoningEndedType string
const (
	EventSessionNextReasoningEndedTypeSessionNextReasoningEnded EventSessionNextReasoningEndedType = "session.next.reasoning.ended"
)

type EventSessionNextReasoningStarted 

type EventSessionNextReasoningStarted struct {
	ID         string                                     `json:"id" api:"required"`
	Properties EventSessionNextReasoningStartedProperties `json:"properties" api:"required"`
	// Any of "session.next.reasoning.started".
	Type EventSessionNextReasoningStartedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextReasoningStarted) RawJSON 

func (r EventSessionNextReasoningStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextReasoningStarted) UnmarshalJSON 

func (r *EventSessionNextReasoningStarted) UnmarshalJSON(data []byte) error

type EventSessionNextReasoningStartedProperties 

type EventSessionNextReasoningStartedProperties struct {
	ReasoningID string  `json:"reasoningID" api:"required"`
	SessionID   string  `json:"sessionID" api:"required"`
	Timestamp   float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ReasoningID respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextReasoningStartedProperties) RawJSON 

func (r EventSessionNextReasoningStartedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextReasoningStartedProperties) UnmarshalJSON 

func (r *EventSessionNextReasoningStartedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextReasoningStartedType 

type EventSessionNextReasoningStartedType string
const (
	EventSessionNextReasoningStartedTypeSessionNextReasoningStarted EventSessionNextReasoningStartedType = "session.next.reasoning.started"
)

type EventSessionNextRetried 

type EventSessionNextRetried struct {
	ID         string                            `json:"id" api:"required"`
	Properties EventSessionNextRetriedProperties `json:"properties" api:"required"`
	// Any of "session.next.retried".
	Type EventSessionNextRetriedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextRetried) RawJSON 

func (r EventSessionNextRetried) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextRetried) UnmarshalJSON 

func (r *EventSessionNextRetried) UnmarshalJSON(data []byte) error

type EventSessionNextRetriedProperties 

type EventSessionNextRetriedProperties struct {
	Attempt   float64               `json:"attempt" api:"required"`
	Error     SessionNextRetryError `json:"error" api:"required"`
	SessionID string                `json:"sessionID" api:"required"`
	Timestamp float64               `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Attempt     respjson.Field
		Error       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextRetriedProperties) RawJSON 

func (r EventSessionNextRetriedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextRetriedProperties) UnmarshalJSON 

func (r *EventSessionNextRetriedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextRetriedType 

type EventSessionNextRetriedType string
const (
	EventSessionNextRetriedTypeSessionNextRetried EventSessionNextRetriedType = "session.next.retried"
)

type EventSessionNextShellEnded 

type EventSessionNextShellEnded struct {
	ID         string                               `json:"id" api:"required"`
	Properties EventSessionNextShellEndedProperties `json:"properties" api:"required"`
	// Any of "session.next.shell.ended".
	Type EventSessionNextShellEndedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextShellEnded) RawJSON 

func (r EventSessionNextShellEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextShellEnded) UnmarshalJSON 

func (r *EventSessionNextShellEnded) UnmarshalJSON(data []byte) error

type EventSessionNextShellEndedProperties 

type EventSessionNextShellEndedProperties struct {
	CallID    string  `json:"callID" api:"required"`
	Output    string  `json:"output" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Output      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextShellEndedProperties) RawJSON 

func (r EventSessionNextShellEndedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextShellEndedProperties) UnmarshalJSON 

func (r *EventSessionNextShellEndedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextShellEndedType 

type EventSessionNextShellEndedType string
const (
	EventSessionNextShellEndedTypeSessionNextShellEnded EventSessionNextShellEndedType = "session.next.shell.ended"
)

type EventSessionNextShellStarted 

type EventSessionNextShellStarted struct {
	ID         string                                 `json:"id" api:"required"`
	Properties EventSessionNextShellStartedProperties `json:"properties" api:"required"`
	// Any of "session.next.shell.started".
	Type EventSessionNextShellStartedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextShellStarted) RawJSON 

func (r EventSessionNextShellStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextShellStarted) UnmarshalJSON 

func (r *EventSessionNextShellStarted) UnmarshalJSON(data []byte) error

type EventSessionNextShellStartedProperties 

type EventSessionNextShellStartedProperties struct {
	CallID    string  `json:"callID" api:"required"`
	Command   string  `json:"command" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Command     respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextShellStartedProperties) RawJSON 

func (r EventSessionNextShellStartedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextShellStartedProperties) UnmarshalJSON 

func (r *EventSessionNextShellStartedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextShellStartedType 

type EventSessionNextShellStartedType string
const (
	EventSessionNextShellStartedTypeSessionNextShellStarted EventSessionNextShellStartedType = "session.next.shell.started"
)

type EventSessionNextStepEnded 

type EventSessionNextStepEnded struct {
	ID         string                              `json:"id" api:"required"`
	Properties EventSessionNextStepEndedProperties `json:"properties" api:"required"`
	// Any of "session.next.step.ended".
	Type EventSessionNextStepEndedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepEnded) RawJSON 

func (r EventSessionNextStepEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepEnded) UnmarshalJSON 

func (r *EventSessionNextStepEnded) UnmarshalJSON(data []byte) error

type EventSessionNextStepEndedProperties 

type EventSessionNextStepEndedProperties struct {
	Cost      float64                                   `json:"cost" api:"required"`
	Finish    string                                    `json:"finish" api:"required"`
	SessionID string                                    `json:"sessionID" api:"required"`
	Timestamp float64                                   `json:"timestamp" api:"required"`
	Tokens    EventSessionNextStepEndedPropertiesTokens `json:"tokens" api:"required"`
	Snapshot  string                                    `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cost        respjson.Field
		Finish      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		Tokens      respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepEndedProperties) RawJSON 

func (r EventSessionNextStepEndedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepEndedProperties) UnmarshalJSON 

func (r *EventSessionNextStepEndedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextStepEndedPropertiesTokens 

type EventSessionNextStepEndedPropertiesTokens struct {
	Cache     EventSessionNextStepEndedPropertiesTokensCache `json:"cache" api:"required"`
	Input     float64                                        `json:"input" api:"required"`
	Output    float64                                        `json:"output" api:"required"`
	Reasoning float64                                        `json:"reasoning" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepEndedPropertiesTokens) RawJSON 

func (r EventSessionNextStepEndedPropertiesTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepEndedPropertiesTokens) UnmarshalJSON 

func (r *EventSessionNextStepEndedPropertiesTokens) UnmarshalJSON(data []byte) error

type EventSessionNextStepEndedPropertiesTokensCache 

type EventSessionNextStepEndedPropertiesTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepEndedPropertiesTokensCache) RawJSON 

func (r EventSessionNextStepEndedPropertiesTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepEndedPropertiesTokensCache) UnmarshalJSON 

func (r *EventSessionNextStepEndedPropertiesTokensCache) UnmarshalJSON(data []byte) error

type EventSessionNextStepEndedType 

type EventSessionNextStepEndedType string
const (
	EventSessionNextStepEndedTypeSessionNextStepEnded EventSessionNextStepEndedType = "session.next.step.ended"
)

type EventSessionNextStepFailed 

type EventSessionNextStepFailed struct {
	ID         string                               `json:"id" api:"required"`
	Properties EventSessionNextStepFailedProperties `json:"properties" api:"required"`
	// Any of "session.next.step.failed".
	Type EventSessionNextStepFailedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepFailed) RawJSON 

func (r EventSessionNextStepFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepFailed) UnmarshalJSON 

func (r *EventSessionNextStepFailed) UnmarshalJSON(data []byte) error

type EventSessionNextStepFailedProperties 

type EventSessionNextStepFailedProperties struct {
	Error     SessionErrorUnknown `json:"error" api:"required"`
	SessionID string              `json:"sessionID" api:"required"`
	Timestamp float64             `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepFailedProperties) RawJSON 

func (r EventSessionNextStepFailedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepFailedProperties) UnmarshalJSON 

func (r *EventSessionNextStepFailedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextStepFailedType 

type EventSessionNextStepFailedType string
const (
	EventSessionNextStepFailedTypeSessionNextStepFailed EventSessionNextStepFailedType = "session.next.step.failed"
)

type EventSessionNextStepStarted 

type EventSessionNextStepStarted struct {
	ID         string                                `json:"id" api:"required"`
	Properties EventSessionNextStepStartedProperties `json:"properties" api:"required"`
	// Any of "session.next.step.started".
	Type EventSessionNextStepStartedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepStarted) RawJSON 

func (r EventSessionNextStepStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepStarted) UnmarshalJSON 

func (r *EventSessionNextStepStarted) UnmarshalJSON(data []byte) error

type EventSessionNextStepStartedProperties 

type EventSessionNextStepStartedProperties struct {
	Agent     string                                     `json:"agent" api:"required"`
	Model     EventSessionNextStepStartedPropertiesModel `json:"model" api:"required"`
	SessionID string                                     `json:"sessionID" api:"required"`
	Timestamp float64                                    `json:"timestamp" api:"required"`
	Snapshot  string                                     `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Agent       respjson.Field
		Model       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepStartedProperties) RawJSON 

func (r EventSessionNextStepStartedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepStartedProperties) UnmarshalJSON 

func (r *EventSessionNextStepStartedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextStepStartedPropertiesModel 

type EventSessionNextStepStartedPropertiesModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextStepStartedPropertiesModel) RawJSON 

func (r EventSessionNextStepStartedPropertiesModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextStepStartedPropertiesModel) UnmarshalJSON 

func (r *EventSessionNextStepStartedPropertiesModel) UnmarshalJSON(data []byte) error

type EventSessionNextStepStartedType 

type EventSessionNextStepStartedType string
const (
	EventSessionNextStepStartedTypeSessionNextStepStarted EventSessionNextStepStartedType = "session.next.step.started"
)

type EventSessionNextSynthetic 

type EventSessionNextSynthetic struct {
	ID         string                              `json:"id" api:"required"`
	Properties EventSessionNextSyntheticProperties `json:"properties" api:"required"`
	// Any of "session.next.synthetic".
	Type EventSessionNextSyntheticType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextSynthetic) RawJSON 

func (r EventSessionNextSynthetic) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextSynthetic) UnmarshalJSON 

func (r *EventSessionNextSynthetic) UnmarshalJSON(data []byte) error

type EventSessionNextSyntheticProperties 

type EventSessionNextSyntheticProperties struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextSyntheticProperties) RawJSON 

func (r EventSessionNextSyntheticProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextSyntheticProperties) UnmarshalJSON 

func (r *EventSessionNextSyntheticProperties) UnmarshalJSON(data []byte) error

type EventSessionNextSyntheticType 

type EventSessionNextSyntheticType string
const (
	EventSessionNextSyntheticTypeSessionNextSynthetic EventSessionNextSyntheticType = "session.next.synthetic"
)

type EventSessionNextTextDelta 

type EventSessionNextTextDelta struct {
	ID         string                              `json:"id" api:"required"`
	Properties EventSessionNextTextDeltaProperties `json:"properties" api:"required"`
	// Any of "session.next.text.delta".
	Type EventSessionNextTextDeltaType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextTextDelta) RawJSON 

func (r EventSessionNextTextDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextTextDelta) UnmarshalJSON 

func (r *EventSessionNextTextDelta) UnmarshalJSON(data []byte) error

type EventSessionNextTextDeltaProperties 

type EventSessionNextTextDeltaProperties struct {
	Delta     string  `json:"delta" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Delta       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextTextDeltaProperties) RawJSON 

func (r EventSessionNextTextDeltaProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextTextDeltaProperties) UnmarshalJSON 

func (r *EventSessionNextTextDeltaProperties) UnmarshalJSON(data []byte) error

type EventSessionNextTextDeltaType 

type EventSessionNextTextDeltaType string
const (
	EventSessionNextTextDeltaTypeSessionNextTextDelta EventSessionNextTextDeltaType = "session.next.text.delta"
)

type EventSessionNextTextEnded 

type EventSessionNextTextEnded struct {
	ID         string                              `json:"id" api:"required"`
	Properties EventSessionNextTextEndedProperties `json:"properties" api:"required"`
	// Any of "session.next.text.ended".
	Type EventSessionNextTextEndedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextTextEnded) RawJSON 

func (r EventSessionNextTextEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextTextEnded) UnmarshalJSON 

func (r *EventSessionNextTextEnded) UnmarshalJSON(data []byte) error

type EventSessionNextTextEndedProperties 

type EventSessionNextTextEndedProperties struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextTextEndedProperties) RawJSON 

func (r EventSessionNextTextEndedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextTextEndedProperties) UnmarshalJSON 

func (r *EventSessionNextTextEndedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextTextEndedType 

type EventSessionNextTextEndedType string
const (
	EventSessionNextTextEndedTypeSessionNextTextEnded EventSessionNextTextEndedType = "session.next.text.ended"
)

type EventSessionNextTextStarted 

type EventSessionNextTextStarted struct {
	ID         string                                `json:"id" api:"required"`
	Properties EventSessionNextTextStartedProperties `json:"properties" api:"required"`
	// Any of "session.next.text.started".
	Type EventSessionNextTextStartedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextTextStarted) RawJSON 

func (r EventSessionNextTextStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextTextStarted) UnmarshalJSON 

func (r *EventSessionNextTextStarted) UnmarshalJSON(data []byte) error

type EventSessionNextTextStartedProperties 

type EventSessionNextTextStartedProperties struct {
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextTextStartedProperties) RawJSON 

func (r EventSessionNextTextStartedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextTextStartedProperties) UnmarshalJSON 

func (r *EventSessionNextTextStartedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextTextStartedType 

type EventSessionNextTextStartedType string
const (
	EventSessionNextTextStartedTypeSessionNextTextStarted EventSessionNextTextStartedType = "session.next.text.started"
)

type EventSessionNextToolCalled 

type EventSessionNextToolCalled struct {
	ID         string                               `json:"id" api:"required"`
	Properties EventSessionNextToolCalledProperties `json:"properties" api:"required"`
	// Any of "session.next.tool.called".
	Type EventSessionNextToolCalledType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolCalled) RawJSON 

func (r EventSessionNextToolCalled) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolCalled) UnmarshalJSON 

func (r *EventSessionNextToolCalled) UnmarshalJSON(data []byte) error

type EventSessionNextToolCalledProperties 

type EventSessionNextToolCalledProperties struct {
	CallID    string                                       `json:"callID" api:"required"`
	Input     map[string]any                               `json:"input" api:"required"`
	Provider  EventSessionNextToolCalledPropertiesProvider `json:"provider" api:"required"`
	SessionID string                                       `json:"sessionID" api:"required"`
	Timestamp float64                                      `json:"timestamp" api:"required"`
	Tool      string                                       `json:"tool" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Input       respjson.Field
		Provider    respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		Tool        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolCalledProperties) RawJSON 

func (r EventSessionNextToolCalledProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolCalledProperties) UnmarshalJSON 

func (r *EventSessionNextToolCalledProperties) UnmarshalJSON(data []byte) error

type EventSessionNextToolCalledPropertiesProvider 

type EventSessionNextToolCalledPropertiesProvider struct {
	Executed bool           `json:"executed" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Executed    respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolCalledPropertiesProvider) RawJSON 

func (r EventSessionNextToolCalledPropertiesProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolCalledPropertiesProvider) UnmarshalJSON 

func (r *EventSessionNextToolCalledPropertiesProvider) UnmarshalJSON(data []byte) error

type EventSessionNextToolCalledType 

type EventSessionNextToolCalledType string
const (
	EventSessionNextToolCalledTypeSessionNextToolCalled EventSessionNextToolCalledType = "session.next.tool.called"
)

type EventSessionNextToolFailed 

type EventSessionNextToolFailed struct {
	ID         string                               `json:"id" api:"required"`
	Properties EventSessionNextToolFailedProperties `json:"properties" api:"required"`
	// Any of "session.next.tool.failed".
	Type EventSessionNextToolFailedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolFailed) RawJSON 

func (r EventSessionNextToolFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolFailed) UnmarshalJSON 

func (r *EventSessionNextToolFailed) UnmarshalJSON(data []byte) error

type EventSessionNextToolFailedProperties 

type EventSessionNextToolFailedProperties struct {
	CallID    string                                       `json:"callID" api:"required"`
	Error     SessionErrorUnknown                          `json:"error" api:"required"`
	Provider  EventSessionNextToolFailedPropertiesProvider `json:"provider" api:"required"`
	SessionID string                                       `json:"sessionID" api:"required"`
	Timestamp float64                                      `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Error       respjson.Field
		Provider    respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolFailedProperties) RawJSON 

func (r EventSessionNextToolFailedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolFailedProperties) UnmarshalJSON 

func (r *EventSessionNextToolFailedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextToolFailedPropertiesProvider 

type EventSessionNextToolFailedPropertiesProvider struct {
	Executed bool           `json:"executed" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Executed    respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolFailedPropertiesProvider) RawJSON 

func (r EventSessionNextToolFailedPropertiesProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolFailedPropertiesProvider) UnmarshalJSON 

func (r *EventSessionNextToolFailedPropertiesProvider) UnmarshalJSON(data []byte) error

type EventSessionNextToolFailedType 

type EventSessionNextToolFailedType string
const (
	EventSessionNextToolFailedTypeSessionNextToolFailed EventSessionNextToolFailedType = "session.next.tool.failed"
)

type EventSessionNextToolInputDelta 

type EventSessionNextToolInputDelta struct {
	ID         string                                   `json:"id" api:"required"`
	Properties EventSessionNextToolInputDeltaProperties `json:"properties" api:"required"`
	// Any of "session.next.tool.input.delta".
	Type EventSessionNextToolInputDeltaType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolInputDelta) RawJSON 

func (r EventSessionNextToolInputDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolInputDelta) UnmarshalJSON 

func (r *EventSessionNextToolInputDelta) UnmarshalJSON(data []byte) error

type EventSessionNextToolInputDeltaProperties 

type EventSessionNextToolInputDeltaProperties struct {
	CallID    string  `json:"callID" api:"required"`
	Delta     string  `json:"delta" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Delta       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolInputDeltaProperties) RawJSON 

func (r EventSessionNextToolInputDeltaProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolInputDeltaProperties) UnmarshalJSON 

func (r *EventSessionNextToolInputDeltaProperties) UnmarshalJSON(data []byte) error

type EventSessionNextToolInputDeltaType 

type EventSessionNextToolInputDeltaType string
const (
	EventSessionNextToolInputDeltaTypeSessionNextToolInputDelta EventSessionNextToolInputDeltaType = "session.next.tool.input.delta"
)

type EventSessionNextToolInputEnded 

type EventSessionNextToolInputEnded struct {
	ID         string                                   `json:"id" api:"required"`
	Properties EventSessionNextToolInputEndedProperties `json:"properties" api:"required"`
	// Any of "session.next.tool.input.ended".
	Type EventSessionNextToolInputEndedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolInputEnded) RawJSON 

func (r EventSessionNextToolInputEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolInputEnded) UnmarshalJSON 

func (r *EventSessionNextToolInputEnded) UnmarshalJSON(data []byte) error

type EventSessionNextToolInputEndedProperties 

type EventSessionNextToolInputEndedProperties struct {
	CallID    string  `json:"callID" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolInputEndedProperties) RawJSON 

func (r EventSessionNextToolInputEndedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolInputEndedProperties) UnmarshalJSON 

func (r *EventSessionNextToolInputEndedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextToolInputEndedType 

type EventSessionNextToolInputEndedType string
const (
	EventSessionNextToolInputEndedTypeSessionNextToolInputEnded EventSessionNextToolInputEndedType = "session.next.tool.input.ended"
)

type EventSessionNextToolInputStarted 

type EventSessionNextToolInputStarted struct {
	ID         string                                     `json:"id" api:"required"`
	Properties EventSessionNextToolInputStartedProperties `json:"properties" api:"required"`
	// Any of "session.next.tool.input.started".
	Type EventSessionNextToolInputStartedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolInputStarted) RawJSON 

func (r EventSessionNextToolInputStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolInputStarted) UnmarshalJSON 

func (r *EventSessionNextToolInputStarted) UnmarshalJSON(data []byte) error

type EventSessionNextToolInputStartedProperties 

type EventSessionNextToolInputStartedProperties struct {
	CallID    string  `json:"callID" api:"required"`
	Name      string  `json:"name" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Name        respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolInputStartedProperties) RawJSON 

func (r EventSessionNextToolInputStartedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolInputStartedProperties) UnmarshalJSON 

func (r *EventSessionNextToolInputStartedProperties) UnmarshalJSON(data []byte) error

type EventSessionNextToolInputStartedType 

type EventSessionNextToolInputStartedType string
const (
	EventSessionNextToolInputStartedTypeSessionNextToolInputStarted EventSessionNextToolInputStartedType = "session.next.tool.input.started"
)

type EventSessionNextToolProgress 

type EventSessionNextToolProgress struct {
	ID         string                                 `json:"id" api:"required"`
	Properties EventSessionNextToolProgressProperties `json:"properties" api:"required"`
	// Any of "session.next.tool.progress".
	Type EventSessionNextToolProgressType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolProgress) RawJSON 

func (r EventSessionNextToolProgress) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolProgress) UnmarshalJSON 

func (r *EventSessionNextToolProgress) UnmarshalJSON(data []byte) error

type EventSessionNextToolProgressProperties 

type EventSessionNextToolProgressProperties struct {
	CallID     string                                               `json:"callID" api:"required"`
	Content    []EventSessionNextToolProgressPropertiesContentUnion `json:"content" api:"required"`
	SessionID  string                                               `json:"sessionID" api:"required"`
	Structured map[string]any                                       `json:"structured" api:"required"`
	Timestamp  float64                                              `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Content     respjson.Field
		SessionID   respjson.Field
		Structured  respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolProgressProperties) RawJSON 

func (r EventSessionNextToolProgressProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolProgressProperties) UnmarshalJSON 

func (r *EventSessionNextToolProgressProperties) UnmarshalJSON(data []byte) error

type EventSessionNextToolProgressPropertiesContentUnion 

type EventSessionNextToolProgressPropertiesContentUnion struct {
	// This field is from variant [ToolTextContent].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [ToolFileContent].
	Mime string `json:"mime"`
	// This field is from variant [ToolFileContent].
	Uri string `json:"uri"`
	// This field is from variant [ToolFileContent].
	Name string `json:"name"`
	JSON struct {
		Text respjson.Field
		Type respjson.Field
		Mime respjson.Field
		Uri  respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventSessionNextToolProgressPropertiesContentUnion contains all possible properties and values from ToolTextContent, ToolFileContent.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (EventSessionNextToolProgressPropertiesContentUnion) AsToolFileContent 

func (u EventSessionNextToolProgressPropertiesContentUnion) AsToolFileContent() (v ToolFileContent)

func (EventSessionNextToolProgressPropertiesContentUnion) AsToolTextContent 

func (u EventSessionNextToolProgressPropertiesContentUnion) AsToolTextContent() (v ToolTextContent)

func (EventSessionNextToolProgressPropertiesContentUnion) RawJSON 

func (u EventSessionNextToolProgressPropertiesContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolProgressPropertiesContentUnion) UnmarshalJSON 

func (r *EventSessionNextToolProgressPropertiesContentUnion) UnmarshalJSON(data []byte) error

type EventSessionNextToolProgressType 

type EventSessionNextToolProgressType string
const (
	EventSessionNextToolProgressTypeSessionNextToolProgress EventSessionNextToolProgressType = "session.next.tool.progress"
)

type EventSessionNextToolSuccess 

type EventSessionNextToolSuccess struct {
	ID         string                                `json:"id" api:"required"`
	Properties EventSessionNextToolSuccessProperties `json:"properties" api:"required"`
	// Any of "session.next.tool.success".
	Type EventSessionNextToolSuccessType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolSuccess) RawJSON 

func (r EventSessionNextToolSuccess) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolSuccess) UnmarshalJSON 

func (r *EventSessionNextToolSuccess) UnmarshalJSON(data []byte) error

type EventSessionNextToolSuccessProperties 

type EventSessionNextToolSuccessProperties struct {
	CallID     string                                              `json:"callID" api:"required"`
	Content    []EventSessionNextToolSuccessPropertiesContentUnion `json:"content" api:"required"`
	Provider   EventSessionNextToolSuccessPropertiesProvider       `json:"provider" api:"required"`
	SessionID  string                                              `json:"sessionID" api:"required"`
	Structured map[string]any                                      `json:"structured" api:"required"`
	Timestamp  float64                                             `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Content     respjson.Field
		Provider    respjson.Field
		SessionID   respjson.Field
		Structured  respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolSuccessProperties) RawJSON 

func (r EventSessionNextToolSuccessProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolSuccessProperties) UnmarshalJSON 

func (r *EventSessionNextToolSuccessProperties) UnmarshalJSON(data []byte) error

type EventSessionNextToolSuccessPropertiesContentUnion 

type EventSessionNextToolSuccessPropertiesContentUnion struct {
	// This field is from variant [ToolTextContent].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [ToolFileContent].
	Mime string `json:"mime"`
	// This field is from variant [ToolFileContent].
	Uri string `json:"uri"`
	// This field is from variant [ToolFileContent].
	Name string `json:"name"`
	JSON struct {
		Text respjson.Field
		Type respjson.Field
		Mime respjson.Field
		Uri  respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventSessionNextToolSuccessPropertiesContentUnion contains all possible properties and values from ToolTextContent, ToolFileContent.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (EventSessionNextToolSuccessPropertiesContentUnion) AsToolFileContent 

func (u EventSessionNextToolSuccessPropertiesContentUnion) AsToolFileContent() (v ToolFileContent)

func (EventSessionNextToolSuccessPropertiesContentUnion) AsToolTextContent 

func (u EventSessionNextToolSuccessPropertiesContentUnion) AsToolTextContent() (v ToolTextContent)

func (EventSessionNextToolSuccessPropertiesContentUnion) RawJSON 

func (u EventSessionNextToolSuccessPropertiesContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolSuccessPropertiesContentUnion) UnmarshalJSON 

func (r *EventSessionNextToolSuccessPropertiesContentUnion) UnmarshalJSON(data []byte) error

type EventSessionNextToolSuccessPropertiesProvider 

type EventSessionNextToolSuccessPropertiesProvider struct {
	Executed bool           `json:"executed" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Executed    respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionNextToolSuccessPropertiesProvider) RawJSON 

func (r EventSessionNextToolSuccessPropertiesProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionNextToolSuccessPropertiesProvider) UnmarshalJSON 

func (r *EventSessionNextToolSuccessPropertiesProvider) UnmarshalJSON(data []byte) error

type EventSessionNextToolSuccessType 

type EventSessionNextToolSuccessType string
const (
	EventSessionNextToolSuccessTypeSessionNextToolSuccess EventSessionNextToolSuccessType = "session.next.tool.success"
)

type EventSessionStatus 

type EventSessionStatus struct {
	ID         string                       `json:"id" api:"required"`
	Properties EventSessionStatusProperties `json:"properties" api:"required"`
	// Any of "session.status".
	Type EventSessionStatusType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionStatus) RawJSON 

func (r EventSessionStatus) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionStatus) UnmarshalJSON 

func (r *EventSessionStatus) UnmarshalJSON(data []byte) error

type EventSessionStatusProperties 

type EventSessionStatusProperties struct {
	SessionID string                                  `json:"sessionID" api:"required"`
	Status    EventSessionStatusPropertiesStatusUnion `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionStatusProperties) RawJSON 

func (r EventSessionStatusProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionStatusProperties) UnmarshalJSON 

func (r *EventSessionStatusProperties) UnmarshalJSON(data []byte) error

type EventSessionStatusPropertiesStatusObject 

type EventSessionStatusPropertiesStatusObject struct {
	Attempt int64  `json:"attempt" api:"required"`
	Message string `json:"message" api:"required"`
	Next    int64  `json:"next" api:"required"`
	// Any of "retry".
	Type   string                                         `json:"type" api:"required"`
	Action EventSessionStatusPropertiesStatusObjectAction `json:"action"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Attempt     respjson.Field
		Message     respjson.Field
		Next        respjson.Field
		Type        respjson.Field
		Action      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionStatusPropertiesStatusObject) RawJSON 

func (r EventSessionStatusPropertiesStatusObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionStatusPropertiesStatusObject) UnmarshalJSON 

func (r *EventSessionStatusPropertiesStatusObject) UnmarshalJSON(data []byte) error

type EventSessionStatusPropertiesStatusObjectAction 

type EventSessionStatusPropertiesStatusObjectAction struct {
	Label    string `json:"label" api:"required"`
	Message  string `json:"message" api:"required"`
	Provider string `json:"provider" api:"required"`
	Reason   string `json:"reason" api:"required"`
	Title    string `json:"title" api:"required"`
	Link     string `json:"link"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Label       respjson.Field
		Message     respjson.Field
		Provider    respjson.Field
		Reason      respjson.Field
		Title       respjson.Field
		Link        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionStatusPropertiesStatusObjectAction) RawJSON 

func (r EventSessionStatusPropertiesStatusObjectAction) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionStatusPropertiesStatusObjectAction) UnmarshalJSON 

func (r *EventSessionStatusPropertiesStatusObjectAction) UnmarshalJSON(data []byte) error

type EventSessionStatusPropertiesStatusType 

type EventSessionStatusPropertiesStatusType struct {
	// Any of "idle".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionStatusPropertiesStatusType) RawJSON 

func (r EventSessionStatusPropertiesStatusType) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionStatusPropertiesStatusType) UnmarshalJSON 

func (r *EventSessionStatusPropertiesStatusType) UnmarshalJSON(data []byte) error

type EventSessionStatusPropertiesStatusType2 

type EventSessionStatusPropertiesStatusType2 struct {
	// Any of "busy".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionStatusPropertiesStatusType2) RawJSON 

func (r EventSessionStatusPropertiesStatusType2) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionStatusPropertiesStatusType2) UnmarshalJSON 

func (r *EventSessionStatusPropertiesStatusType2) UnmarshalJSON(data []byte) error

type EventSessionStatusPropertiesStatusUnion 

type EventSessionStatusPropertiesStatusUnion struct {
	Type string `json:"type"`
	// This field is from variant [EventSessionStatusPropertiesStatusObject].
	Attempt int64 `json:"attempt"`
	// This field is from variant [EventSessionStatusPropertiesStatusObject].
	Message string `json:"message"`
	// This field is from variant [EventSessionStatusPropertiesStatusObject].
	Next int64 `json:"next"`
	// This field is from variant [EventSessionStatusPropertiesStatusObject].
	Action EventSessionStatusPropertiesStatusObjectAction `json:"action"`
	JSON   struct {
		Type    respjson.Field
		Attempt respjson.Field
		Message respjson.Field
		Next    respjson.Field
		Action  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

EventSessionStatusPropertiesStatusUnion contains all possible properties and values from EventSessionStatusPropertiesStatusType, EventSessionStatusPropertiesStatusObject, EventSessionStatusPropertiesStatusType2.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (EventSessionStatusPropertiesStatusUnion) AsEventSessionStatusPropertiesStatusObject 

func (u EventSessionStatusPropertiesStatusUnion) AsEventSessionStatusPropertiesStatusObject() (v EventSessionStatusPropertiesStatusObject)

func (EventSessionStatusPropertiesStatusUnion) AsEventSessionStatusPropertiesStatusType 

func (u EventSessionStatusPropertiesStatusUnion) AsEventSessionStatusPropertiesStatusType() (v EventSessionStatusPropertiesStatusType)

func (EventSessionStatusPropertiesStatusUnion) AsEventSessionStatusPropertiesStatusType2 

func (u EventSessionStatusPropertiesStatusUnion) AsEventSessionStatusPropertiesStatusType2() (v EventSessionStatusPropertiesStatusType2)

func (EventSessionStatusPropertiesStatusUnion) RawJSON 

func (u EventSessionStatusPropertiesStatusUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionStatusPropertiesStatusUnion) UnmarshalJSON 

func (r *EventSessionStatusPropertiesStatusUnion) UnmarshalJSON(data []byte) error

type EventSessionStatusType 

type EventSessionStatusType string
const (
	EventSessionStatusTypeSessionStatus EventSessionStatusType = "session.status"
)

type EventSessionUpdated 

type EventSessionUpdated struct {
	ID         string                        `json:"id" api:"required"`
	Properties EventSessionUpdatedProperties `json:"properties" api:"required"`
	// Any of "session.updated".
	Type EventSessionUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionUpdated) RawJSON 

func (r EventSessionUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionUpdated) UnmarshalJSON 

func (r *EventSessionUpdated) UnmarshalJSON(data []byte) error

type EventSessionUpdatedProperties 

type EventSessionUpdatedProperties struct {
	Info      Session `json:"info" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventSessionUpdatedProperties) RawJSON 

func (r EventSessionUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventSessionUpdatedProperties) UnmarshalJSON 

func (r *EventSessionUpdatedProperties) UnmarshalJSON(data []byte) error

type EventSessionUpdatedType 

type EventSessionUpdatedType string
const (
	EventSessionUpdatedTypeSessionUpdated EventSessionUpdatedType = "session.updated"
)

type EventTodoUpdated 

type EventTodoUpdated struct {
	ID         string                     `json:"id" api:"required"`
	Properties EventTodoUpdatedProperties `json:"properties" api:"required"`
	// Any of "todo.updated".
	Type EventTodoUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTodoUpdated) RawJSON 

func (r EventTodoUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTodoUpdated) UnmarshalJSON 

func (r *EventTodoUpdated) UnmarshalJSON(data []byte) error

type EventTodoUpdatedProperties 

type EventTodoUpdatedProperties struct {
	SessionID string `json:"sessionID" api:"required"`
	Todos     []Todo `json:"todos" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Todos       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTodoUpdatedProperties) RawJSON 

func (r EventTodoUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTodoUpdatedProperties) UnmarshalJSON 

func (r *EventTodoUpdatedProperties) UnmarshalJSON(data []byte) error

type EventTodoUpdatedType 

type EventTodoUpdatedType string
const (
	EventTodoUpdatedTypeTodoUpdated EventTodoUpdatedType = "todo.updated"
)

type EventTuiCommandExecute 

type EventTuiCommandExecute struct {
	ID         string                           `json:"id" api:"required"`
	Properties EventTuiCommandExecuteProperties `json:"properties" api:"required"`
	// Any of "tui.command.execute".
	Type EventTuiCommandExecuteType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTuiCommandExecute) RawJSON 

func (r EventTuiCommandExecute) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTuiCommandExecute) UnmarshalJSON 

func (r *EventTuiCommandExecute) UnmarshalJSON(data []byte) error

type EventTuiCommandExecuteProperties 

type EventTuiCommandExecuteProperties struct {
	Command string `json:"command" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTuiCommandExecuteProperties) RawJSON 

func (r EventTuiCommandExecuteProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTuiCommandExecuteProperties) UnmarshalJSON 

func (r *EventTuiCommandExecuteProperties) UnmarshalJSON(data []byte) error

type EventTuiCommandExecuteType 

type EventTuiCommandExecuteType string
const (
	EventTuiCommandExecuteTypeTuiCommandExecute EventTuiCommandExecuteType = "tui.command.execute"
)

type EventTuiPromptAppend 

type EventTuiPromptAppend struct {
	ID         string                         `json:"id" api:"required"`
	Properties EventTuiPromptAppendProperties `json:"properties" api:"required"`
	// Any of "tui.prompt.append".
	Type EventTuiPromptAppendType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTuiPromptAppend) RawJSON 

func (r EventTuiPromptAppend) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTuiPromptAppend) UnmarshalJSON 

func (r *EventTuiPromptAppend) UnmarshalJSON(data []byte) error

type EventTuiPromptAppendProperties 

type EventTuiPromptAppendProperties struct {
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTuiPromptAppendProperties) RawJSON 

func (r EventTuiPromptAppendProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTuiPromptAppendProperties) UnmarshalJSON 

func (r *EventTuiPromptAppendProperties) UnmarshalJSON(data []byte) error

type EventTuiPromptAppendType 

type EventTuiPromptAppendType string
const (
	EventTuiPromptAppendTypeTuiPromptAppend EventTuiPromptAppendType = "tui.prompt.append"
)

type EventTuiSessionSelect 

type EventTuiSessionSelect struct {
	ID         string                          `json:"id" api:"required"`
	Properties EventTuiSessionSelectProperties `json:"properties" api:"required"`
	// Any of "tui.session.select".
	Type EventTuiSessionSelectType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTuiSessionSelect) RawJSON 

func (r EventTuiSessionSelect) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTuiSessionSelect) UnmarshalJSON 

func (r *EventTuiSessionSelect) UnmarshalJSON(data []byte) error

type EventTuiSessionSelectProperties 

type EventTuiSessionSelectProperties struct {
	// Session ID to navigate to
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventTuiSessionSelectProperties) RawJSON 

func (r EventTuiSessionSelectProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventTuiSessionSelectProperties) UnmarshalJSON 

func (r *EventTuiSessionSelectProperties) UnmarshalJSON(data []byte) error

type EventTuiSessionSelectType 

type EventTuiSessionSelectType string
const (
	EventTuiSessionSelectTypeTuiSessionSelect EventTuiSessionSelectType = "tui.session.select"
)

type EventVcsBranchUpdated 

type EventVcsBranchUpdated struct {
	ID         string                          `json:"id" api:"required"`
	Properties EventVcsBranchUpdatedProperties `json:"properties" api:"required"`
	// Any of "vcs.branch.updated".
	Type EventVcsBranchUpdatedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventVcsBranchUpdated) RawJSON 

func (r EventVcsBranchUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventVcsBranchUpdated) UnmarshalJSON 

func (r *EventVcsBranchUpdated) UnmarshalJSON(data []byte) error

type EventVcsBranchUpdatedProperties 

type EventVcsBranchUpdatedProperties struct {
	Branch string `json:"branch"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Branch      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventVcsBranchUpdatedProperties) RawJSON 

func (r EventVcsBranchUpdatedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventVcsBranchUpdatedProperties) UnmarshalJSON 

func (r *EventVcsBranchUpdatedProperties) UnmarshalJSON(data []byte) error

type EventVcsBranchUpdatedType 

type EventVcsBranchUpdatedType string
const (
	EventVcsBranchUpdatedTypeVcsBranchUpdated EventVcsBranchUpdatedType = "vcs.branch.updated"
)

type EventWorkspaceFailed 

type EventWorkspaceFailed struct {
	ID         string                         `json:"id" api:"required"`
	Properties EventWorkspaceFailedProperties `json:"properties" api:"required"`
	// Any of "workspace.failed".
	Type EventWorkspaceFailedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorkspaceFailed) RawJSON 

func (r EventWorkspaceFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorkspaceFailed) UnmarshalJSON 

func (r *EventWorkspaceFailed) UnmarshalJSON(data []byte) error

type EventWorkspaceFailedProperties 

type EventWorkspaceFailedProperties struct {
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorkspaceFailedProperties) RawJSON 

func (r EventWorkspaceFailedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorkspaceFailedProperties) UnmarshalJSON 

func (r *EventWorkspaceFailedProperties) UnmarshalJSON(data []byte) error

type EventWorkspaceFailedType 

type EventWorkspaceFailedType string
const (
	EventWorkspaceFailedTypeWorkspaceFailed EventWorkspaceFailedType = "workspace.failed"
)

type EventWorkspaceReady 

type EventWorkspaceReady struct {
	ID         string                        `json:"id" api:"required"`
	Properties EventWorkspaceReadyProperties `json:"properties" api:"required"`
	// Any of "workspace.ready".
	Type EventWorkspaceReadyType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorkspaceReady) RawJSON 

func (r EventWorkspaceReady) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorkspaceReady) UnmarshalJSON 

func (r *EventWorkspaceReady) UnmarshalJSON(data []byte) error

type EventWorkspaceReadyProperties 

type EventWorkspaceReadyProperties struct {
	Name string `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorkspaceReadyProperties) RawJSON 

func (r EventWorkspaceReadyProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorkspaceReadyProperties) UnmarshalJSON 

func (r *EventWorkspaceReadyProperties) UnmarshalJSON(data []byte) error

type EventWorkspaceReadyType 

type EventWorkspaceReadyType string
const (
	EventWorkspaceReadyTypeWorkspaceReady EventWorkspaceReadyType = "workspace.ready"
)

type EventWorkspaceStatus 

type EventWorkspaceStatus struct {
	ID         string                         `json:"id" api:"required"`
	Properties EventWorkspaceStatusProperties `json:"properties" api:"required"`
	// Any of "workspace.status".
	Type EventWorkspaceStatusType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorkspaceStatus) RawJSON 

func (r EventWorkspaceStatus) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorkspaceStatus) UnmarshalJSON 

func (r *EventWorkspaceStatus) UnmarshalJSON(data []byte) error

type EventWorkspaceStatusProperties 

type EventWorkspaceStatusProperties struct {
	// Any of "connected", "connecting", "disconnected", "error".
	Status      string `json:"status" api:"required"`
	WorkspaceID string `json:"workspaceID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		WorkspaceID respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorkspaceStatusProperties) RawJSON 

func (r EventWorkspaceStatusProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorkspaceStatusProperties) UnmarshalJSON 

func (r *EventWorkspaceStatusProperties) UnmarshalJSON(data []byte) error

type EventWorkspaceStatusType 

type EventWorkspaceStatusType string
const (
	EventWorkspaceStatusTypeWorkspaceStatus EventWorkspaceStatusType = "workspace.status"
)

type EventWorktreeFailed 

type EventWorktreeFailed struct {
	ID         string                        `json:"id" api:"required"`
	Properties EventWorktreeFailedProperties `json:"properties" api:"required"`
	// Any of "worktree.failed".
	Type EventWorktreeFailedType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorktreeFailed) RawJSON 

func (r EventWorktreeFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorktreeFailed) UnmarshalJSON 

func (r *EventWorktreeFailed) UnmarshalJSON(data []byte) error

type EventWorktreeFailedProperties 

type EventWorktreeFailedProperties struct {
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorktreeFailedProperties) RawJSON 

func (r EventWorktreeFailedProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorktreeFailedProperties) UnmarshalJSON 

func (r *EventWorktreeFailedProperties) UnmarshalJSON(data []byte) error

type EventWorktreeFailedType 

type EventWorktreeFailedType string
const (
	EventWorktreeFailedTypeWorktreeFailed EventWorktreeFailedType = "worktree.failed"
)

type EventWorktreeReady 

type EventWorktreeReady struct {
	ID         string                       `json:"id" api:"required"`
	Properties EventWorktreeReadyProperties `json:"properties" api:"required"`
	// Any of "worktree.ready".
	Type EventWorktreeReadyType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorktreeReady) RawJSON 

func (r EventWorktreeReady) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorktreeReady) UnmarshalJSON 

func (r *EventWorktreeReady) UnmarshalJSON(data []byte) error

type EventWorktreeReadyProperties 

type EventWorktreeReadyProperties struct {
	Name   string `json:"name" api:"required"`
	Branch string `json:"branch"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Name        respjson.Field
		Branch      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (EventWorktreeReadyProperties) RawJSON 

func (r EventWorktreeReadyProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*EventWorktreeReadyProperties) UnmarshalJSON 

func (r *EventWorktreeReadyProperties) UnmarshalJSON(data []byte) error

type EventWorktreeReadyType 

type EventWorktreeReadyType string
const (
	EventWorktreeReadyTypeWorktreeReady EventWorktreeReadyType = "worktree.ready"
)

type ExperimentalConsoleGetParams 

type ExperimentalConsoleGetParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalConsoleGetParams) URLQuery 

func (r ExperimentalConsoleGetParams) URLQuery() (v url.Values, err error)

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

type ExperimentalConsoleGetResponse 

type ExperimentalConsoleGetResponse struct {
	ConsoleManagedProviders []string `json:"consoleManagedProviders" api:"required"`
	SwitchableOrgCount      int64    `json:"switchableOrgCount" api:"required"`
	ActiveOrgName           string   `json:"activeOrgName"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ConsoleManagedProviders respjson.Field
		SwitchableOrgCount      respjson.Field
		ActiveOrgName           respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalConsoleGetResponse) RawJSON 

func (r ExperimentalConsoleGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalConsoleGetResponse) UnmarshalJSON 

func (r *ExperimentalConsoleGetResponse) UnmarshalJSON(data []byte) error

type ExperimentalConsoleListOrgsParams 

type ExperimentalConsoleListOrgsParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalConsoleListOrgsParams) URLQuery 

func (r ExperimentalConsoleListOrgsParams) URLQuery() (v url.Values, err error)

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

type ExperimentalConsoleListOrgsResponse 

type ExperimentalConsoleListOrgsResponse struct {
	Orgs []ExperimentalConsoleListOrgsResponseOrg `json:"orgs" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Orgs        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Switchable Console orgs

func (ExperimentalConsoleListOrgsResponse) RawJSON 

func (r ExperimentalConsoleListOrgsResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalConsoleListOrgsResponse) UnmarshalJSON 

func (r *ExperimentalConsoleListOrgsResponse) UnmarshalJSON(data []byte) error

type ExperimentalConsoleListOrgsResponseOrg 

type ExperimentalConsoleListOrgsResponseOrg struct {
	AccountEmail string `json:"accountEmail" api:"required"`
	AccountID    string `json:"accountID" api:"required"`
	AccountURL   string `json:"accountUrl" api:"required"`
	Active       bool   `json:"active" api:"required"`
	OrgID        string `json:"orgID" api:"required"`
	OrgName      string `json:"orgName" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AccountEmail respjson.Field
		AccountID    respjson.Field
		AccountURL   respjson.Field
		Active       respjson.Field
		OrgID        respjson.Field
		OrgName      respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalConsoleListOrgsResponseOrg) RawJSON 

func (r ExperimentalConsoleListOrgsResponseOrg) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalConsoleListOrgsResponseOrg) UnmarshalJSON 

func (r *ExperimentalConsoleListOrgsResponseOrg) UnmarshalJSON(data []byte) error

type ExperimentalConsoleService 

type ExperimentalConsoleService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi read-only routes.

ExperimentalConsoleService contains methods and other services that help with interacting with the opencode-stainless 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 NewExperimentalConsoleService method instead.

func NewExperimentalConsoleService 

func NewExperimentalConsoleService(opts ...option.RequestOption) (r ExperimentalConsoleService)

NewExperimentalConsoleService 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 (*ExperimentalConsoleService) Get 

func (r *ExperimentalConsoleService) Get(ctx context.Context, query ExperimentalConsoleGetParams, opts ...option.RequestOption) (res *ExperimentalConsoleGetResponse, err error)

Get the active Console org name and the set of provider IDs managed by that Console org.

func (*ExperimentalConsoleService) ListOrgs 

func (r *ExperimentalConsoleService) ListOrgs(ctx context.Context, query ExperimentalConsoleListOrgsParams, opts ...option.RequestOption) (res *ExperimentalConsoleListOrgsResponse, err error)

Get the available Console orgs across logged-in accounts, including the current active org.

func (*ExperimentalConsoleService) SwitchOrg 

func (r *ExperimentalConsoleService) SwitchOrg(ctx context.Context, params ExperimentalConsoleSwitchOrgParams, opts ...option.RequestOption) (res *bool, err error)

Persist a new active Console account/org selection for the current local OpenCode state.

type ExperimentalConsoleSwitchOrgParams 

type ExperimentalConsoleSwitchOrgParams struct {
	AccountID string            `json:"accountID" api:"required"`
	OrgID     string            `json:"orgID" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalConsoleSwitchOrgParams) MarshalJSON 

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

func (ExperimentalConsoleSwitchOrgParams) URLQuery 

func (r ExperimentalConsoleSwitchOrgParams) URLQuery() (v url.Values, err error)

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

func (*ExperimentalConsoleSwitchOrgParams) UnmarshalJSON 

func (r *ExperimentalConsoleSwitchOrgParams) UnmarshalJSON(data []byte) error

type ExperimentalGetResourcesParams 

type ExperimentalGetResourcesParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalGetResourcesParams) URLQuery 

func (r ExperimentalGetResourcesParams) URLQuery() (v url.Values, err error)

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

type ExperimentalGetResourcesResponse 

type ExperimentalGetResourcesResponse map[string]ExperimentalGetResourcesResponseItem

type ExperimentalGetResourcesResponseItem 

type ExperimentalGetResourcesResponseItem struct {
	Client      string `json:"client" api:"required"`
	Name        string `json:"name" api:"required"`
	Uri         string `json:"uri" api:"required"`
	Description string `json:"description"`
	MimeType    string `json:"mimeType"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Client      respjson.Field
		Name        respjson.Field
		Uri         respjson.Field
		Description respjson.Field
		MimeType    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalGetResourcesResponseItem) RawJSON 

func (r ExperimentalGetResourcesResponseItem) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalGetResourcesResponseItem) UnmarshalJSON 

func (r *ExperimentalGetResourcesResponseItem) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsParams 

type ExperimentalListSessionsParams struct {
	Cursor    param.Opt[float64]                          `query:"cursor,omitzero" json:"-"`
	Directory param.Opt[string]                           `query:"directory,omitzero" json:"-"`
	Limit     param.Opt[float64]                          `query:"limit,omitzero" json:"-"`
	Search    param.Opt[string]                           `query:"search,omitzero" json:"-"`
	Start     param.Opt[float64]                          `query:"start,omitzero" json:"-"`
	Workspace param.Opt[string]                           `query:"workspace,omitzero" json:"-"`
	Archived  ExperimentalListSessionsParamsArchivedUnion `query:"archived,omitzero" json:"-"`
	Roots     ExperimentalListSessionsParamsRootsUnion    `query:"roots,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalListSessionsParams) URLQuery 

func (r ExperimentalListSessionsParams) URLQuery() (v url.Values, err error)

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

type ExperimentalListSessionsParamsArchivedString 

type ExperimentalListSessionsParamsArchivedString string
const (
	ExperimentalListSessionsParamsArchivedStringTrue  ExperimentalListSessionsParamsArchivedString = "true"
	ExperimentalListSessionsParamsArchivedStringFalse ExperimentalListSessionsParamsArchivedString = "false"
)

type ExperimentalListSessionsParamsArchivedUnion 

type ExperimentalListSessionsParamsArchivedUnion struct {
	OfBool param.Opt[bool] `query:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfExperimentalListSessionssArchivedString)
	OfExperimentalListSessionssArchivedString param.Opt[string] `query:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

type ExperimentalListSessionsParamsRootsString 

type ExperimentalListSessionsParamsRootsString string
const (
	ExperimentalListSessionsParamsRootsStringTrue  ExperimentalListSessionsParamsRootsString = "true"
	ExperimentalListSessionsParamsRootsStringFalse ExperimentalListSessionsParamsRootsString = "false"
)

type ExperimentalListSessionsParamsRootsUnion 

type ExperimentalListSessionsParamsRootsUnion struct {
	OfBool param.Opt[bool] `query:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfExperimentalListSessionssRootsString)
	OfExperimentalListSessionssRootsString param.Opt[string] `query:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

type ExperimentalListSessionsResponse 

type ExperimentalListSessionsResponse struct {
	ID          string                                  `json:"id" api:"required"`
	Directory   string                                  `json:"directory" api:"required"`
	Project     ExperimentalListSessionsResponseProject `json:"project" api:"required"`
	ProjectID   string                                  `json:"projectID" api:"required"`
	Slug        string                                  `json:"slug" api:"required"`
	Time        ExperimentalListSessionsResponseTime    `json:"time" api:"required"`
	Title       string                                  `json:"title" api:"required"`
	Version     string                                  `json:"version" api:"required"`
	Agent       string                                  `json:"agent"`
	Cost        float64                                 `json:"cost"`
	Model       ExperimentalListSessionsResponseModel   `json:"model"`
	ParentID    string                                  `json:"parentID"`
	Path        string                                  `json:"path"`
	Permission  []PermissionRule                        `json:"permission"`
	Revert      ExperimentalListSessionsResponseRevert  `json:"revert"`
	Share       ExperimentalListSessionsResponseShare   `json:"share"`
	Summary     ExperimentalListSessionsResponseSummary `json:"summary"`
	Tokens      ExperimentalListSessionsResponseTokens  `json:"tokens"`
	WorkspaceID string                                  `json:"workspaceID"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Directory   respjson.Field
		Project     respjson.Field
		ProjectID   respjson.Field
		Slug        respjson.Field
		Time        respjson.Field
		Title       respjson.Field
		Version     respjson.Field
		Agent       respjson.Field
		Cost        respjson.Field
		Model       respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		Permission  respjson.Field
		Revert      respjson.Field
		Share       respjson.Field
		Summary     respjson.Field
		Tokens      respjson.Field
		WorkspaceID respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponse) RawJSON 

func (r ExperimentalListSessionsResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponse) UnmarshalJSON 

func (r *ExperimentalListSessionsResponse) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseModel 

type ExperimentalListSessionsResponseModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseModel) RawJSON 

func (r ExperimentalListSessionsResponseModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseModel) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseModel) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseProject 

type ExperimentalListSessionsResponseProject struct {
	ID       string `json:"id" api:"required"`
	Worktree string `json:"worktree" api:"required"`
	Name     string `json:"name"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Worktree    respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseProject) RawJSON 

func (r ExperimentalListSessionsResponseProject) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseProject) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseProject) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseRevert 

type ExperimentalListSessionsResponseRevert struct {
	MessageID string `json:"messageID" api:"required"`
	Diff      string `json:"diff"`
	PartID    string `json:"partID"`
	Snapshot  string `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MessageID   respjson.Field
		Diff        respjson.Field
		PartID      respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseRevert) RawJSON 

func (r ExperimentalListSessionsResponseRevert) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseRevert) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseRevert) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseShare 

type ExperimentalListSessionsResponseShare struct {
	URL string `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseShare) RawJSON 

func (r ExperimentalListSessionsResponseShare) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseShare) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseShare) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseSummary 

type ExperimentalListSessionsResponseSummary struct {
	Additions float64            `json:"additions" api:"required"`
	Deletions float64            `json:"deletions" api:"required"`
	Files     float64            `json:"files" api:"required"`
	Diffs     []SnapshotFileDiff `json:"diffs"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Additions   respjson.Field
		Deletions   respjson.Field
		Files       respjson.Field
		Diffs       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseSummary) RawJSON 

func (r ExperimentalListSessionsResponseSummary) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseSummary) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseSummary) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseTime 

type ExperimentalListSessionsResponseTime struct {
	Created    int64   `json:"created" api:"required"`
	Updated    int64   `json:"updated" api:"required"`
	Archived   float64 `json:"archived"`
	Compacting int64   `json:"compacting"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Updated     respjson.Field
		Archived    respjson.Field
		Compacting  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseTime) RawJSON 

func (r ExperimentalListSessionsResponseTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseTime) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseTime) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseTokens 

type ExperimentalListSessionsResponseTokens struct {
	Cache     ExperimentalListSessionsResponseTokensCache `json:"cache" api:"required"`
	Input     float64                                     `json:"input" api:"required"`
	Output    float64                                     `json:"output" api:"required"`
	Reasoning float64                                     `json:"reasoning" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseTokens) RawJSON 

func (r ExperimentalListSessionsResponseTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseTokens) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseTokens) UnmarshalJSON(data []byte) error

type ExperimentalListSessionsResponseTokensCache 

type ExperimentalListSessionsResponseTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalListSessionsResponseTokensCache) RawJSON 

func (r ExperimentalListSessionsResponseTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalListSessionsResponseTokensCache) UnmarshalJSON 

func (r *ExperimentalListSessionsResponseTokensCache) UnmarshalJSON(data []byte) error

type ExperimentalService 

type ExperimentalService struct {

	// Experimental HttpApi read-only routes.
	Console ExperimentalConsoleService
	// Experimental HttpApi read-only routes.
	Tool ExperimentalToolService
	// Experimental HttpApi read-only routes.
	Worktree ExperimentalWorktreeService
	// Experimental HttpApi workspace routes.
	Workspace ExperimentalWorkspaceService
	// contains filtered or unexported fields
}

Experimental HttpApi read-only routes.

ExperimentalService contains methods and other services that help with interacting with the opencode-stainless 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 NewExperimentalService method instead.

func NewExperimentalService 

func NewExperimentalService(opts ...option.RequestOption) (r ExperimentalService)

NewExperimentalService 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 (*ExperimentalService) GetResources 

func (r *ExperimentalService) GetResources(ctx context.Context, query ExperimentalGetResourcesParams, opts ...option.RequestOption) (res *ExperimentalGetResourcesResponse, err error)

Get all available MCP resources from connected servers. Optionally filter by name.

func (*ExperimentalService) ListSessions 

func (r *ExperimentalService) ListSessions(ctx context.Context, query ExperimentalListSessionsParams, opts ...option.RequestOption) (res *[]ExperimentalListSessionsResponse, err error)

Get a list of all OpenCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.

type ExperimentalToolListIDsParams 

type ExperimentalToolListIDsParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalToolListIDsParams) URLQuery 

func (r ExperimentalToolListIDsParams) URLQuery() (v url.Values, err error)

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

type ExperimentalToolListParams 

type ExperimentalToolListParams struct {
	Model     string            `query:"model" api:"required" json:"-"`
	Provider  string            `query:"provider" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalToolListParams) URLQuery 

func (r ExperimentalToolListParams) URLQuery() (v url.Values, err error)

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

type ExperimentalToolListResponse 

type ExperimentalToolListResponse struct {
	ID          string `json:"id" api:"required"`
	Description string `json:"description" api:"required"`
	Parameters  any    `json:"parameters" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Description respjson.Field
		Parameters  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalToolListResponse) RawJSON 

func (r ExperimentalToolListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalToolListResponse) UnmarshalJSON 

func (r *ExperimentalToolListResponse) UnmarshalJSON(data []byte) error

type ExperimentalToolService 

type ExperimentalToolService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi read-only routes.

ExperimentalToolService contains methods and other services that help with interacting with the opencode-stainless 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 NewExperimentalToolService method instead.

func NewExperimentalToolService 

func NewExperimentalToolService(opts ...option.RequestOption) (r ExperimentalToolService)

NewExperimentalToolService 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 (*ExperimentalToolService) List 

func (r *ExperimentalToolService) List(ctx context.Context, query ExperimentalToolListParams, opts ...option.RequestOption) (res *[]ExperimentalToolListResponse, err error)

Get a list of available tools with their JSON schema parameters for a specific provider and model combination.

func (*ExperimentalToolService) ListIDs 

func (r *ExperimentalToolService) ListIDs(ctx context.Context, query ExperimentalToolListIDsParams, opts ...option.RequestOption) (res *[]string, err error)

Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.

type ExperimentalWorkspaceGetStatusParams 

type ExperimentalWorkspaceGetStatusParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorkspaceGetStatusParams) URLQuery 

func (r ExperimentalWorkspaceGetStatusParams) URLQuery() (v url.Values, err error)

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

type ExperimentalWorkspaceGetStatusResponse 

type ExperimentalWorkspaceGetStatusResponse struct {
	// Any of "connected", "connecting", "disconnected", "error".
	Status      ExperimentalWorkspaceGetStatusResponseStatus `json:"status" api:"required"`
	WorkspaceID string                                       `json:"workspaceID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		WorkspaceID respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalWorkspaceGetStatusResponse) RawJSON 

func (r ExperimentalWorkspaceGetStatusResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalWorkspaceGetStatusResponse) UnmarshalJSON 

func (r *ExperimentalWorkspaceGetStatusResponse) UnmarshalJSON(data []byte) error

type ExperimentalWorkspaceGetStatusResponseStatus 

type ExperimentalWorkspaceGetStatusResponseStatus string
const (
	ExperimentalWorkspaceGetStatusResponseStatusConnected    ExperimentalWorkspaceGetStatusResponseStatus = "connected"
	ExperimentalWorkspaceGetStatusResponseStatusConnecting   ExperimentalWorkspaceGetStatusResponseStatus = "connecting"
	ExperimentalWorkspaceGetStatusResponseStatusDisconnected ExperimentalWorkspaceGetStatusResponseStatus = "disconnected"
	ExperimentalWorkspaceGetStatusResponseStatusError        ExperimentalWorkspaceGetStatusResponseStatus = "error"
)

type ExperimentalWorkspaceListAdaptersParams 

type ExperimentalWorkspaceListAdaptersParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorkspaceListAdaptersParams) URLQuery 

func (r ExperimentalWorkspaceListAdaptersParams) URLQuery() (v url.Values, err error)

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

type ExperimentalWorkspaceListAdaptersResponse 

type ExperimentalWorkspaceListAdaptersResponse struct {
	Description string `json:"description" api:"required"`
	Name        string `json:"name" api:"required"`
	Type        string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Description respjson.Field
		Name        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalWorkspaceListAdaptersResponse) RawJSON 

func (r ExperimentalWorkspaceListAdaptersResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalWorkspaceListAdaptersResponse) UnmarshalJSON 

func (r *ExperimentalWorkspaceListAdaptersResponse) UnmarshalJSON(data []byte) error

type ExperimentalWorkspaceListParams 

type ExperimentalWorkspaceListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorkspaceListParams) URLQuery 

func (r ExperimentalWorkspaceListParams) URLQuery() (v url.Values, err error)

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

type ExperimentalWorkspaceNewParams 

type ExperimentalWorkspaceNewParams struct {
	Type      string            `json:"type" api:"required"`
	Branch    param.Opt[string] `json:"branch,omitzero"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	ID        param.Opt[string] `json:"id,omitzero"`
	Extra     any               `json:"extra"`
	// contains filtered or unexported fields
}

func (ExperimentalWorkspaceNewParams) MarshalJSON 

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

func (ExperimentalWorkspaceNewParams) URLQuery 

func (r ExperimentalWorkspaceNewParams) URLQuery() (v url.Values, err error)

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

func (*ExperimentalWorkspaceNewParams) UnmarshalJSON 

func (r *ExperimentalWorkspaceNewParams) UnmarshalJSON(data []byte) error

type ExperimentalWorkspaceRemoveParams 

type ExperimentalWorkspaceRemoveParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorkspaceRemoveParams) URLQuery 

func (r ExperimentalWorkspaceRemoveParams) URLQuery() (v url.Values, err error)

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

type ExperimentalWorkspaceService 

type ExperimentalWorkspaceService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi workspace routes.

ExperimentalWorkspaceService contains methods and other services that help with interacting with the opencode-stainless 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 NewExperimentalWorkspaceService method instead.

func NewExperimentalWorkspaceService 

func NewExperimentalWorkspaceService(opts ...option.RequestOption) (r ExperimentalWorkspaceService)

NewExperimentalWorkspaceService 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 (*ExperimentalWorkspaceService) GetStatus 

func (r *ExperimentalWorkspaceService) GetStatus(ctx context.Context, query ExperimentalWorkspaceGetStatusParams, opts ...option.RequestOption) (res *[]ExperimentalWorkspaceGetStatusResponse, err error)

Get connection status for workspaces in the current project.

func (*ExperimentalWorkspaceService) List 

func (r *ExperimentalWorkspaceService) List(ctx context.Context, query ExperimentalWorkspaceListParams, opts ...option.RequestOption) (res *[]Workspace, err error)

List all workspaces.

func (*ExperimentalWorkspaceService) ListAdapters 

func (r *ExperimentalWorkspaceService) ListAdapters(ctx context.Context, query ExperimentalWorkspaceListAdaptersParams, opts ...option.RequestOption) (res *[]ExperimentalWorkspaceListAdaptersResponse, err error)

List all available workspace adapters for the current project.

func (*ExperimentalWorkspaceService) New 

func (r *ExperimentalWorkspaceService) New(ctx context.Context, params ExperimentalWorkspaceNewParams, opts ...option.RequestOption) (res *Workspace, err error)

Create a workspace for the current project.

func (*ExperimentalWorkspaceService) Remove 

func (r *ExperimentalWorkspaceService) Remove(ctx context.Context, id string, body ExperimentalWorkspaceRemoveParams, opts ...option.RequestOption) (res *Workspace, err error)

Remove an existing workspace.

func (*ExperimentalWorkspaceService) SyncList 

func (r *ExperimentalWorkspaceService) SyncList(ctx context.Context, body ExperimentalWorkspaceSyncListParams, opts ...option.RequestOption) (err error)

Register missing workspaces returned by workspace adapters.

func (*ExperimentalWorkspaceService) WarpSession 

func (r *ExperimentalWorkspaceService) WarpSession(ctx context.Context, params ExperimentalWorkspaceWarpSessionParams, opts ...option.RequestOption) (err error)

Move a session's sync history into the target workspace, or detach it to the local project.

type ExperimentalWorkspaceSyncListParams 

type ExperimentalWorkspaceSyncListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorkspaceSyncListParams) URLQuery 

func (r ExperimentalWorkspaceSyncListParams) URLQuery() (v url.Values, err error)

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

type ExperimentalWorkspaceWarpSessionParams 

type ExperimentalWorkspaceWarpSessionParams struct {
	ID          param.Opt[string] `json:"id,omitzero" api:"required"`
	SessionID   string            `json:"sessionID" api:"required"`
	Directory   param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace   param.Opt[string] `query:"workspace,omitzero" json:"-"`
	CopyChanges param.Opt[bool]   `json:"copyChanges,omitzero"`
	// contains filtered or unexported fields
}

func (ExperimentalWorkspaceWarpSessionParams) MarshalJSON 

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

func (ExperimentalWorkspaceWarpSessionParams) URLQuery 

func (r ExperimentalWorkspaceWarpSessionParams) URLQuery() (v url.Values, err error)

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

func (*ExperimentalWorkspaceWarpSessionParams) UnmarshalJSON 

func (r *ExperimentalWorkspaceWarpSessionParams) UnmarshalJSON(data []byte) error

type ExperimentalWorktreeListParams 

type ExperimentalWorktreeListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorktreeListParams) URLQuery 

func (r ExperimentalWorktreeListParams) URLQuery() (v url.Values, err error)

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

type ExperimentalWorktreeNewParams 

type ExperimentalWorktreeNewParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Name      param.Opt[string] `json:"name,omitzero"`
	// Additional startup script to run after the project's start command
	StartCommand param.Opt[string] `json:"startCommand,omitzero"`
	// contains filtered or unexported fields
}

func (ExperimentalWorktreeNewParams) MarshalJSON 

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

func (ExperimentalWorktreeNewParams) URLQuery 

func (r ExperimentalWorktreeNewParams) URLQuery() (v url.Values, err error)

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

func (*ExperimentalWorktreeNewParams) UnmarshalJSON 

func (r *ExperimentalWorktreeNewParams) UnmarshalJSON(data []byte) error

type ExperimentalWorktreeNewResponse 

type ExperimentalWorktreeNewResponse struct {
	Directory string `json:"directory" api:"required"`
	Name      string `json:"name" api:"required"`
	Branch    string `json:"branch"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Directory   respjson.Field
		Name        respjson.Field
		Branch      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ExperimentalWorktreeNewResponse) RawJSON 

func (r ExperimentalWorktreeNewResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ExperimentalWorktreeNewResponse) UnmarshalJSON 

func (r *ExperimentalWorktreeNewResponse) UnmarshalJSON(data []byte) error

type ExperimentalWorktreeRemoveParams 

type ExperimentalWorktreeRemoveParams struct {
	BodyDirectory  string            `json:"directory" api:"required"`
	QueryDirectory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace      param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorktreeRemoveParams) MarshalJSON 

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

func (ExperimentalWorktreeRemoveParams) URLQuery 

func (r ExperimentalWorktreeRemoveParams) URLQuery() (v url.Values, err error)

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

func (*ExperimentalWorktreeRemoveParams) UnmarshalJSON 

func (r *ExperimentalWorktreeRemoveParams) UnmarshalJSON(data []byte) error

type ExperimentalWorktreeResetParams 

type ExperimentalWorktreeResetParams struct {
	BodyDirectory  string            `json:"directory" api:"required"`
	QueryDirectory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace      param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ExperimentalWorktreeResetParams) MarshalJSON 

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

func (ExperimentalWorktreeResetParams) URLQuery 

func (r ExperimentalWorktreeResetParams) URLQuery() (v url.Values, err error)

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

func (*ExperimentalWorktreeResetParams) UnmarshalJSON 

func (r *ExperimentalWorktreeResetParams) UnmarshalJSON(data []byte) error

type ExperimentalWorktreeService 

type ExperimentalWorktreeService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi read-only routes.

ExperimentalWorktreeService contains methods and other services that help with interacting with the opencode-stainless 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 NewExperimentalWorktreeService method instead.

func NewExperimentalWorktreeService 

func NewExperimentalWorktreeService(opts ...option.RequestOption) (r ExperimentalWorktreeService)

NewExperimentalWorktreeService 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 (*ExperimentalWorktreeService) List 

func (r *ExperimentalWorktreeService) List(ctx context.Context, query ExperimentalWorktreeListParams, opts ...option.RequestOption) (res *[]string, err error)

List all sandbox worktrees for the current project.

func (*ExperimentalWorktreeService) New 

func (r *ExperimentalWorktreeService) New(ctx context.Context, params ExperimentalWorktreeNewParams, opts ...option.RequestOption) (res *ExperimentalWorktreeNewResponse, err error)

Create a new git worktree for the current project and run any configured startup scripts.

func (*ExperimentalWorktreeService) Remove 

func (r *ExperimentalWorktreeService) Remove(ctx context.Context, params ExperimentalWorktreeRemoveParams, opts ...option.RequestOption) (res *bool, err error)

Remove a git worktree and delete its branch.

func (*ExperimentalWorktreeService) Reset 

func (r *ExperimentalWorktreeService) Reset(ctx context.Context, params ExperimentalWorktreeResetParams, opts ...option.RequestOption) (res *bool, err error)

Reset a worktree branch to the primary default branch.

type FileGetStatusParams 

type FileGetStatusParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (FileGetStatusParams) URLQuery 

func (r FileGetStatusParams) URLQuery() (v url.Values, err error)

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

type FileGetStatusResponse 

type FileGetStatusResponse struct {
	Added   int64  `json:"added" api:"required"`
	Path    string `json:"path" api:"required"`
	Removed int64  `json:"removed" api:"required"`
	// Any of "added", "deleted", "modified".
	Status FileGetStatusResponseStatus `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Added       respjson.Field
		Path        respjson.Field
		Removed     respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FileGetStatusResponse) RawJSON 

func (r FileGetStatusResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*FileGetStatusResponse) UnmarshalJSON 

func (r *FileGetStatusResponse) UnmarshalJSON(data []byte) error

type FileGetStatusResponseStatus 

type FileGetStatusResponseStatus string
const (
	FileGetStatusResponseStatusAdded    FileGetStatusResponseStatus = "added"
	FileGetStatusResponseStatusDeleted  FileGetStatusResponseStatus = "deleted"
	FileGetStatusResponseStatusModified FileGetStatusResponseStatus = "modified"
)

type FileListParams 

type FileListParams struct {
	Path      string            `query:"path" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (FileListParams) URLQuery 

func (r FileListParams) URLQuery() (v url.Values, err error)

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

type FileListResponse 

type FileListResponse struct {
	Absolute string `json:"absolute" api:"required"`
	Ignored  bool   `json:"ignored" api:"required"`
	Name     string `json:"name" api:"required"`
	Path     string `json:"path" api:"required"`
	// Any of "file", "directory".
	Type FileListResponseType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Absolute    respjson.Field
		Ignored     respjson.Field
		Name        respjson.Field
		Path        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FileListResponse) RawJSON 

func (r FileListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*FileListResponse) UnmarshalJSON 

func (r *FileListResponse) UnmarshalJSON(data []byte) error

type FileListResponseType 

type FileListResponseType string
const (
	FileListResponseTypeFile      FileListResponseType = "file"
	FileListResponseTypeDirectory FileListResponseType = "directory"
)

type FilePart 

type FilePart struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	Mime      string `json:"mime" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "file".
	Type     FilePartType        `json:"type" api:"required"`
	URL      string              `json:"url" api:"required"`
	Filename string              `json:"filename"`
	Source   FilePartSourceUnion `json:"source"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		MessageID   respjson.Field
		Mime        respjson.Field
		SessionID   respjson.Field
		Type        respjson.Field
		URL         respjson.Field
		Filename    respjson.Field
		Source      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FilePart) RawJSON 

func (r FilePart) RawJSON() string

Returns the unmodified JSON received from the API

func (FilePart) ToParam 

func (r FilePart) ToParam() FilePartParam

ToParam converts this FilePart to a FilePartParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with FilePartParam.Overrides()

func (*FilePart) UnmarshalJSON 

func (r *FilePart) UnmarshalJSON(data []byte) error

type FilePartInputParam 

type FilePartInputParam struct {
	Mime string `json:"mime" api:"required"`
	// Any of "file".
	Type     FilePartInputType        `json:"type,omitzero" api:"required"`
	URL      string                   `json:"url" api:"required"`
	ID       param.Opt[string]        `json:"id,omitzero"`
	Filename param.Opt[string]        `json:"filename,omitzero"`
	Source   FilePartSourceUnionParam `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The properties Mime, Type, URL are required.

func (FilePartInputParam) MarshalJSON 

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

func (*FilePartInputParam) UnmarshalJSON 

func (r *FilePartInputParam) UnmarshalJSON(data []byte) error

type FilePartInputType 

type FilePartInputType string
const (
	FilePartInputTypeFile FilePartInputType = "file"
)

type FilePartParam 

type FilePartParam struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	Mime      string `json:"mime" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "file".
	Type     FilePartType             `json:"type,omitzero" api:"required"`
	URL      string                   `json:"url" api:"required"`
	Filename param.Opt[string]        `json:"filename,omitzero"`
	Source   FilePartSourceUnionParam `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, MessageID, Mime, SessionID, Type, URL are required.

func (FilePartParam) MarshalJSON 

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

func (*FilePartParam) UnmarshalJSON 

func (r *FilePartParam) UnmarshalJSON(data []byte) error

type FilePartSourceFileSource 

type FilePartSourceFileSource struct {
	Path string             `json:"path" api:"required"`
	Text FilePartSourceText `json:"text" api:"required"`
	// Any of "file".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Path        respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FilePartSourceFileSource) RawJSON 

func (r FilePartSourceFileSource) RawJSON() string

Returns the unmodified JSON received from the API

func (*FilePartSourceFileSource) UnmarshalJSON 

func (r *FilePartSourceFileSource) UnmarshalJSON(data []byte) error

type FilePartSourceFileSourceParam 

type FilePartSourceFileSourceParam struct {
	Path string                  `json:"path" api:"required"`
	Text FilePartSourceTextParam `json:"text,omitzero" api:"required"`
	// Any of "file".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Path, Text, Type are required.

func (FilePartSourceFileSourceParam) MarshalJSON 

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

func (*FilePartSourceFileSourceParam) UnmarshalJSON 

func (r *FilePartSourceFileSourceParam) UnmarshalJSON(data []byte) error

type FilePartSourceResourceSource 

type FilePartSourceResourceSource struct {
	ClientName string             `json:"clientName" api:"required"`
	Text       FilePartSourceText `json:"text" api:"required"`
	// Any of "resource".
	Type string `json:"type" api:"required"`
	Uri  string `json:"uri" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ClientName  respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		Uri         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FilePartSourceResourceSource) RawJSON 

func (r FilePartSourceResourceSource) RawJSON() string

Returns the unmodified JSON received from the API

func (*FilePartSourceResourceSource) UnmarshalJSON 

func (r *FilePartSourceResourceSource) UnmarshalJSON(data []byte) error

type FilePartSourceResourceSourceParam 

type FilePartSourceResourceSourceParam struct {
	ClientName string                  `json:"clientName" api:"required"`
	Text       FilePartSourceTextParam `json:"text,omitzero" api:"required"`
	// Any of "resource".
	Type string `json:"type,omitzero" api:"required"`
	Uri  string `json:"uri" api:"required"`
	// contains filtered or unexported fields
}

The properties ClientName, Text, Type, Uri are required.

func (FilePartSourceResourceSourceParam) MarshalJSON 

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

func (*FilePartSourceResourceSourceParam) UnmarshalJSON 

func (r *FilePartSourceResourceSourceParam) UnmarshalJSON(data []byte) error

type FilePartSourceSymbolSource 

type FilePartSourceSymbolSource struct {
	Kind  int64              `json:"kind" api:"required"`
	Name  string             `json:"name" api:"required"`
	Path  string             `json:"path" api:"required"`
	Range Range              `json:"range" api:"required"`
	Text  FilePartSourceText `json:"text" api:"required"`
	// Any of "symbol".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Kind        respjson.Field
		Name        respjson.Field
		Path        respjson.Field
		Range       respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FilePartSourceSymbolSource) RawJSON 

func (r FilePartSourceSymbolSource) RawJSON() string

Returns the unmodified JSON received from the API

func (*FilePartSourceSymbolSource) UnmarshalJSON 

func (r *FilePartSourceSymbolSource) UnmarshalJSON(data []byte) error

type FilePartSourceSymbolSourceParam 

type FilePartSourceSymbolSourceParam struct {
	Kind  int64                   `json:"kind" api:"required"`
	Name  string                  `json:"name" api:"required"`
	Path  string                  `json:"path" api:"required"`
	Range RangeParam              `json:"range,omitzero" api:"required"`
	Text  FilePartSourceTextParam `json:"text,omitzero" api:"required"`
	// Any of "symbol".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Kind, Name, Path, Range, Text, Type are required.

func (FilePartSourceSymbolSourceParam) MarshalJSON 

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

func (*FilePartSourceSymbolSourceParam) UnmarshalJSON 

func (r *FilePartSourceSymbolSourceParam) UnmarshalJSON(data []byte) error

type FilePartSourceText 

type FilePartSourceText struct {
	End   float64 `json:"end" api:"required"`
	Start float64 `json:"start" api:"required"`
	Value string  `json:"value" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Start       respjson.Field
		Value       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FilePartSourceText) RawJSON 

func (r FilePartSourceText) RawJSON() string

Returns the unmodified JSON received from the API

func (FilePartSourceText) ToParam 

func (r FilePartSourceText) ToParam() FilePartSourceTextParam

ToParam converts this FilePartSourceText to a FilePartSourceTextParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with FilePartSourceTextParam.Overrides()

func (*FilePartSourceText) UnmarshalJSON 

func (r *FilePartSourceText) UnmarshalJSON(data []byte) error

type FilePartSourceTextParam 

type FilePartSourceTextParam struct {
	End   float64 `json:"end" api:"required"`
	Start float64 `json:"start" api:"required"`
	Value string  `json:"value" api:"required"`
	// contains filtered or unexported fields
}

The properties End, Start, Value are required.

func (FilePartSourceTextParam) MarshalJSON 

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

func (*FilePartSourceTextParam) UnmarshalJSON 

func (r *FilePartSourceTextParam) UnmarshalJSON(data []byte) error

type FilePartSourceUnion 

type FilePartSourceUnion struct {
	Path string `json:"path"`
	// This field is from variant [FilePartSourceFileSource].
	Text FilePartSourceText `json:"text"`
	Type string             `json:"type"`
	// This field is from variant [FilePartSourceSymbolSource].
	Kind int64 `json:"kind"`
	// This field is from variant [FilePartSourceSymbolSource].
	Name string `json:"name"`
	// This field is from variant [FilePartSourceSymbolSource].
	Range Range `json:"range"`
	// This field is from variant [FilePartSourceResourceSource].
	ClientName string `json:"clientName"`
	// This field is from variant [FilePartSourceResourceSource].
	Uri  string `json:"uri"`
	JSON struct {
		Path       respjson.Field
		Text       respjson.Field
		Type       respjson.Field
		Kind       respjson.Field
		Name       respjson.Field
		Range      respjson.Field
		ClientName respjson.Field
		Uri        respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

FilePartSourceUnion contains all possible properties and values from FilePartSourceFileSource, FilePartSourceSymbolSource, FilePartSourceResourceSource.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (FilePartSourceUnion) AsFilePartSourceFileSource 

func (u FilePartSourceUnion) AsFilePartSourceFileSource() (v FilePartSourceFileSource)

func (FilePartSourceUnion) AsFilePartSourceResourceSource 

func (u FilePartSourceUnion) AsFilePartSourceResourceSource() (v FilePartSourceResourceSource)

func (FilePartSourceUnion) AsFilePartSourceSymbolSource 

func (u FilePartSourceUnion) AsFilePartSourceSymbolSource() (v FilePartSourceSymbolSource)

func (FilePartSourceUnion) RawJSON 

func (u FilePartSourceUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (FilePartSourceUnion) ToParam 

func (r FilePartSourceUnion) ToParam() FilePartSourceUnionParam

ToParam converts this FilePartSourceUnion to a FilePartSourceUnionParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with FilePartSourceUnionParam.Overrides()

func (*FilePartSourceUnion) UnmarshalJSON 

func (r *FilePartSourceUnion) UnmarshalJSON(data []byte) error

type FilePartSourceUnionParam 

type FilePartSourceUnionParam struct {
	OfFilePartSourceFileSource     *FilePartSourceFileSourceParam     `json:",omitzero,inline"`
	OfFilePartSourceSymbolSource   *FilePartSourceSymbolSourceParam   `json:",omitzero,inline"`
	OfFilePartSourceResourceSource *FilePartSourceResourceSourceParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func FilePartSourceParamOfFilePartSourceFileSource 

func FilePartSourceParamOfFilePartSourceFileSource(path string, text FilePartSourceTextParam, type_ string) FilePartSourceUnionParam

func (FilePartSourceUnionParam) MarshalJSON 

func (u FilePartSourceUnionParam) MarshalJSON() ([]byte, error)

func (*FilePartSourceUnionParam) UnmarshalJSON 

func (u *FilePartSourceUnionParam) UnmarshalJSON(data []byte) error

type FilePartType 

type FilePartType string
const (
	FilePartTypeFile FilePartType = "file"
)

type FileReadParams 

type FileReadParams struct {
	Path      string            `query:"path" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (FileReadParams) URLQuery 

func (r FileReadParams) URLQuery() (v url.Values, err error)

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

type FileReadResponse 

type FileReadResponse struct {
	Content string `json:"content" api:"required"`
	// Any of "text", "binary".
	Type FileReadResponseType `json:"type" api:"required"`
	Diff string               `json:"diff"`
	// Any of "base64".
	Encoding FileReadResponseEncoding `json:"encoding"`
	MimeType string                   `json:"mimeType"`
	Patch    FileReadResponsePatch    `json:"patch"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		Type        respjson.Field
		Diff        respjson.Field
		Encoding    respjson.Field
		MimeType    respjson.Field
		Patch       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FileReadResponse) RawJSON 

func (r FileReadResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*FileReadResponse) UnmarshalJSON 

func (r *FileReadResponse) UnmarshalJSON(data []byte) error

type FileReadResponseEncoding 

type FileReadResponseEncoding string
const (
	FileReadResponseEncodingBase64 FileReadResponseEncoding = "base64"
)

type FileReadResponsePatch 

type FileReadResponsePatch struct {
	Hunks       []FileReadResponsePatchHunk `json:"hunks" api:"required"`
	NewFileName string                      `json:"newFileName" api:"required"`
	OldFileName string                      `json:"oldFileName" api:"required"`
	Index       string                      `json:"index"`
	NewHeader   string                      `json:"newHeader"`
	OldHeader   string                      `json:"oldHeader"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Hunks       respjson.Field
		NewFileName respjson.Field
		OldFileName respjson.Field
		Index       respjson.Field
		NewHeader   respjson.Field
		OldHeader   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FileReadResponsePatch) RawJSON 

func (r FileReadResponsePatch) RawJSON() string

Returns the unmodified JSON received from the API

func (*FileReadResponsePatch) UnmarshalJSON 

func (r *FileReadResponsePatch) UnmarshalJSON(data []byte) error

type FileReadResponsePatchHunk 

type FileReadResponsePatchHunk struct {
	Lines    []string `json:"lines" api:"required"`
	NewLines int64    `json:"newLines" api:"required"`
	NewStart int64    `json:"newStart" api:"required"`
	OldLines int64    `json:"oldLines" api:"required"`
	OldStart int64    `json:"oldStart" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Lines       respjson.Field
		NewLines    respjson.Field
		NewStart    respjson.Field
		OldLines    respjson.Field
		OldStart    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FileReadResponsePatchHunk) RawJSON 

func (r FileReadResponsePatchHunk) RawJSON() string

Returns the unmodified JSON received from the API

func (*FileReadResponsePatchHunk) UnmarshalJSON 

func (r *FileReadResponsePatchHunk) UnmarshalJSON(data []byte) error

type FileReadResponseType 

type FileReadResponseType string
const (
	FileReadResponseTypeText   FileReadResponseType = "text"
	FileReadResponseTypeBinary FileReadResponseType = "binary"
)

type FileService 

type FileService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi file routes.

FileService contains methods and other services that help with interacting with the opencode-stainless 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 NewFileService method instead.

func NewFileService 

func NewFileService(opts ...option.RequestOption) (r FileService)

NewFileService 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 (*FileService) GetStatus 

func (r *FileService) GetStatus(ctx context.Context, query FileGetStatusParams, opts ...option.RequestOption) (res *[]FileGetStatusResponse, err error)

Get the git status of all files in the project.

func (*FileService) List 

func (r *FileService) List(ctx context.Context, query FileListParams, opts ...option.RequestOption) (res *[]FileListResponse, err error)

List files and directories in a specified path.

func (*FileService) Read 

func (r *FileService) Read(ctx context.Context, query FileReadParams, opts ...option.RequestOption) (res *FileReadResponse, err error)

Read the content of a specified file.

type FindSearchFilesParams 

type FindSearchFilesParams struct {
	Query     string            `query:"query" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Limit     param.Opt[int64]  `query:"limit,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// Any of "true", "false".
	Dirs FindSearchFilesParamsDirs `query:"dirs,omitzero" json:"-"`
	// Any of "file", "directory".
	Type FindSearchFilesParamsType `query:"type,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (FindSearchFilesParams) URLQuery 

func (r FindSearchFilesParams) URLQuery() (v url.Values, err error)

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

type FindSearchFilesParamsDirs 

type FindSearchFilesParamsDirs string
const (
	FindSearchFilesParamsDirsTrue  FindSearchFilesParamsDirs = "true"
	FindSearchFilesParamsDirsFalse FindSearchFilesParamsDirs = "false"
)

type FindSearchFilesParamsType 

type FindSearchFilesParamsType string
const (
	FindSearchFilesParamsTypeFile      FindSearchFilesParamsType = "file"
	FindSearchFilesParamsTypeDirectory FindSearchFilesParamsType = "directory"
)

type FindSearchParams 

type FindSearchParams struct {
	Pattern   string            `query:"pattern" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (FindSearchParams) URLQuery 

func (r FindSearchParams) URLQuery() (v url.Values, err error)

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

type FindSearchResponse 

type FindSearchResponse struct {
	AbsoluteOffset int64                        `json:"absolute_offset" api:"required"`
	LineNumber     int64                        `json:"line_number" api:"required"`
	Lines          FindSearchResponseLines      `json:"lines" api:"required"`
	Path           FindSearchResponsePath       `json:"path" api:"required"`
	Submatches     []FindSearchResponseSubmatch `json:"submatches" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AbsoluteOffset respjson.Field
		LineNumber     respjson.Field
		Lines          respjson.Field
		Path           respjson.Field
		Submatches     respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FindSearchResponse) RawJSON 

func (r FindSearchResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*FindSearchResponse) UnmarshalJSON 

func (r *FindSearchResponse) UnmarshalJSON(data []byte) error

type FindSearchResponseLines 

type FindSearchResponseLines struct {
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FindSearchResponseLines) RawJSON 

func (r FindSearchResponseLines) RawJSON() string

Returns the unmodified JSON received from the API

func (*FindSearchResponseLines) UnmarshalJSON 

func (r *FindSearchResponseLines) UnmarshalJSON(data []byte) error

type FindSearchResponsePath 

type FindSearchResponsePath struct {
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FindSearchResponsePath) RawJSON 

func (r FindSearchResponsePath) RawJSON() string

Returns the unmodified JSON received from the API

func (*FindSearchResponsePath) UnmarshalJSON 

func (r *FindSearchResponsePath) UnmarshalJSON(data []byte) error

type FindSearchResponseSubmatch 

type FindSearchResponseSubmatch struct {
	End   int64                           `json:"end" api:"required"`
	Match FindSearchResponseSubmatchMatch `json:"match" api:"required"`
	Start int64                           `json:"start" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Match       respjson.Field
		Start       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FindSearchResponseSubmatch) RawJSON 

func (r FindSearchResponseSubmatch) RawJSON() string

Returns the unmodified JSON received from the API

func (*FindSearchResponseSubmatch) UnmarshalJSON 

func (r *FindSearchResponseSubmatch) UnmarshalJSON(data []byte) error

type FindSearchResponseSubmatchMatch 

type FindSearchResponseSubmatchMatch struct {
	Text string `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FindSearchResponseSubmatchMatch) RawJSON 

func (r FindSearchResponseSubmatchMatch) RawJSON() string

Returns the unmodified JSON received from the API

func (*FindSearchResponseSubmatchMatch) UnmarshalJSON 

func (r *FindSearchResponseSubmatchMatch) UnmarshalJSON(data []byte) error

type FindSearchSymbolsParams 

type FindSearchSymbolsParams struct {
	Query     string            `query:"query" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (FindSearchSymbolsParams) URLQuery 

func (r FindSearchSymbolsParams) URLQuery() (v url.Values, err error)

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

type FindSearchSymbolsResponse 

type FindSearchSymbolsResponse struct {
	Kind     int64                             `json:"kind" api:"required"`
	Location FindSearchSymbolsResponseLocation `json:"location" api:"required"`
	Name     string                            `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Kind        respjson.Field
		Location    respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FindSearchSymbolsResponse) RawJSON 

func (r FindSearchSymbolsResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*FindSearchSymbolsResponse) UnmarshalJSON 

func (r *FindSearchSymbolsResponse) UnmarshalJSON(data []byte) error

type FindSearchSymbolsResponseLocation 

type FindSearchSymbolsResponseLocation struct {
	Range Range  `json:"range" api:"required"`
	Uri   string `json:"uri" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Range       respjson.Field
		Uri         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FindSearchSymbolsResponseLocation) RawJSON 

func (r FindSearchSymbolsResponseLocation) RawJSON() string

Returns the unmodified JSON received from the API

func (*FindSearchSymbolsResponseLocation) UnmarshalJSON 

func (r *FindSearchSymbolsResponseLocation) UnmarshalJSON(data []byte) error

type FindService 

type FindService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi file routes.

FindService contains methods and other services that help with interacting with the opencode-stainless 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 NewFindService method instead.

func NewFindService 

func NewFindService(opts ...option.RequestOption) (r FindService)

NewFindService 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 (*FindService) Search 

func (r *FindService) Search(ctx context.Context, query FindSearchParams, opts ...option.RequestOption) (res *[]FindSearchResponse, err error)

Search for text patterns across files in the project using ripgrep.

func (*FindService) SearchFiles 

func (r *FindService) SearchFiles(ctx context.Context, query FindSearchFilesParams, opts ...option.RequestOption) (res *[]string, err error)

Search for files or directories by name or pattern in the project directory.

func (*FindService) SearchSymbols 

func (r *FindService) SearchSymbols(ctx context.Context, query FindSearchSymbolsParams, opts ...option.RequestOption) (res *[]FindSearchSymbolsResponse, err error)

Search for workspace symbols like functions, classes, and variables using LSP.

type FormatterGetParams 

type FormatterGetParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (FormatterGetParams) URLQuery 

func (r FormatterGetParams) URLQuery() (v url.Values, err error)

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

type FormatterGetResponse 

type FormatterGetResponse struct {
	Enabled    bool     `json:"enabled" api:"required"`
	Extensions []string `json:"extensions" api:"required"`
	Name       string   `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Enabled     respjson.Field
		Extensions  respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (FormatterGetResponse) RawJSON 

func (r FormatterGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*FormatterGetResponse) UnmarshalJSON 

func (r *FormatterGetResponse) UnmarshalJSON(data []byte) error

type FormatterService 

type FormatterService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

FormatterService contains methods and other services that help with interacting with the opencode-stainless 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 NewFormatterService method instead.

func NewFormatterService 

func NewFormatterService(opts ...option.RequestOption) (r FormatterService)

NewFormatterService 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 (*FormatterService) Get 

func (r *FormatterService) Get(ctx context.Context, query FormatterGetParams, opts ...option.RequestOption) (res *[]FormatterGetResponse, err error)

Get formatter status

type GlobalConfigService 

type GlobalConfigService struct {
	// contains filtered or unexported fields
}

Global server routes.

GlobalConfigService contains methods and other services that help with interacting with the opencode-stainless 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 NewGlobalConfigService method instead.

func NewGlobalConfigService 

func NewGlobalConfigService(opts ...option.RequestOption) (r GlobalConfigService)

NewGlobalConfigService 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 (*GlobalConfigService) GetConfig 

func (r *GlobalConfigService) GetConfig(ctx context.Context, opts ...option.RequestOption) (res *Config, err error)

Retrieve the current global OpenCode configuration settings and preferences.

func (*GlobalConfigService) UpdateConfig 

func (r *GlobalConfigService) UpdateConfig(ctx context.Context, body GlobalConfigUpdateConfigParams, opts ...option.RequestOption) (res *Config, err error)

Update global OpenCode configuration settings and preferences.

type GlobalConfigUpdateConfigParams 

type GlobalConfigUpdateConfigParams struct {
	Config ConfigParam
	// contains filtered or unexported fields
}

func (GlobalConfigUpdateConfigParams) MarshalJSON 

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

func (*GlobalConfigUpdateConfigParams) UnmarshalJSON 

func (r *GlobalConfigUpdateConfigParams) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponse 

type GlobalGetEventsResponse struct {
	Directory string                              `json:"directory" api:"required"`
	Payload   GlobalGetEventsResponsePayloadUnion `json:"payload" api:"required"`
	Project   string                              `json:"project"`
	Workspace string                              `json:"workspace"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Directory   respjson.Field
		Payload     respjson.Field
		Project     respjson.Field
		Workspace   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponse) RawJSON 

func (r GlobalGetEventsResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponse) UnmarshalJSON 

func (r *GlobalGetEventsResponse) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadEventTuiToastShow 

type GlobalGetEventsResponsePayloadEventTuiToastShow struct {
	ID         string                                                    `json:"id" api:"required"`
	Properties GlobalGetEventsResponsePayloadEventTuiToastShowProperties `json:"properties" api:"required"`
	// Any of "tui.toast.show".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadEventTuiToastShow) RawJSON 

func (r GlobalGetEventsResponsePayloadEventTuiToastShow) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadEventTuiToastShow) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadEventTuiToastShow) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadEventTuiToastShowProperties 

type GlobalGetEventsResponsePayloadEventTuiToastShowProperties struct {
	Message string `json:"message" api:"required"`
	// Any of "info", "success", "warning", "error".
	Variant  string `json:"variant" api:"required"`
	Duration int64  `json:"duration"`
	Title    string `json:"title"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Variant     respjson.Field
		Duration    respjson.Field
		Title       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadEventTuiToastShowProperties) RawJSON 

func (r GlobalGetEventsResponsePayloadEventTuiToastShowProperties) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadEventTuiToastShowProperties) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadEventTuiToastShowProperties) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved 

type GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                        `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData `json:"data" api:"required"`
	// Any of "message.part.removed.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData 

type GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData struct {
	MessageID string `json:"messageID" api:"required"`
	PartID    string `json:"partID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MessageID   respjson.Field
		PartID      respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated 

type GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                        `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData `json:"data" api:"required"`
	// Any of "message.part.updated.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData 

type GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData struct {
	Part      PartUnion `json:"part" api:"required"`
	SessionID string    `json:"sessionID" api:"required"`
	Time      int64     `json:"time" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Part        respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessageRemoved 

type GlobalGetEventsResponsePayloadSyncEventMessageRemoved struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                    `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventMessageRemovedData `json:"data" api:"required"`
	// Any of "message.removed.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessageRemoved) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessageRemoved) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessageRemoved) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessageRemoved) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessageRemovedData 

type GlobalGetEventsResponsePayloadSyncEventMessageRemovedData struct {
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MessageID   respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessageRemovedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessageRemovedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessageRemovedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessageRemovedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessageUpdated 

type GlobalGetEventsResponsePayloadSyncEventMessageUpdated struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                    `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData `json:"data" api:"required"`
	// Any of "message.updated.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessageUpdated) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessageUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessageUpdated) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessageUpdated) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData 

type GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData struct {
	Info      MessageUnion `json:"info" api:"required"`
	SessionID string       `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionCreated 

type GlobalGetEventsResponsePayloadSyncEventSessionCreated struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                    `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionCreatedData `json:"data" api:"required"`
	// Any of "session.created.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionCreated) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionCreated) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionCreated) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionCreated) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionCreatedData 

type GlobalGetEventsResponsePayloadSyncEventSessionCreatedData struct {
	Info      Session `json:"info" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionCreatedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionCreatedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionCreatedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionCreatedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionDeleted 

type GlobalGetEventsResponsePayloadSyncEventSessionDeleted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                    `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionDeletedData `json:"data" api:"required"`
	// Any of "session.deleted.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionDeleted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionDeleted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionDeleted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionDeleted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionDeletedData 

type GlobalGetEventsResponsePayloadSyncEventSessionDeletedData struct {
	Info      Session `json:"info" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionDeletedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionDeletedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionDeletedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionDeletedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched 

type GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                              `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData `json:"data" api:"required"`
	// Any of "session.next.agent.switched.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData struct {
	Agent     string  `json:"agent" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Agent       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta 

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                                `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData `json:"data" api:"required"`
	// Any of "session.next.compaction.delta.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded 

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                                `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData `json:"data" api:"required"`
	// Any of "session.next.compaction.ended.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	Include   string  `json:"include"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		Include     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted 

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                                  `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData `json:"data" api:"required"`
	// Any of "session.next.compaction.started.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData struct {
	// Any of "auto", "manual".
	Reason    string  `json:"reason" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Reason      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched 

type GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                              `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData `json:"data" api:"required"`
	// Any of "session.next.model.switched.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData struct {
	Model     GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel `json:"model" api:"required"`
	SessionID string                                                                   `json:"sessionID" api:"required"`
	Timestamp float64                                                                  `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Model       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel 

type GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted 

type GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                         `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData `json:"data" api:"required"`
	// Any of "session.next.prompted.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData struct {
	Prompt    Prompt  `json:"prompt" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Prompt      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta 

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                               `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData `json:"data" api:"required"`
	// Any of "session.next.reasoning.delta.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData struct {
	Delta       string  `json:"delta" api:"required"`
	ReasoningID string  `json:"reasoningID" api:"required"`
	SessionID   string  `json:"sessionID" api:"required"`
	Timestamp   float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Delta       respjson.Field
		ReasoningID respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded 

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                               `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData `json:"data" api:"required"`
	// Any of "session.next.reasoning.ended.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData struct {
	ReasoningID string  `json:"reasoningID" api:"required"`
	SessionID   string  `json:"sessionID" api:"required"`
	Text        string  `json:"text" api:"required"`
	Timestamp   float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ReasoningID respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted 

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                                 `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData `json:"data" api:"required"`
	// Any of "session.next.reasoning.started.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData struct {
	ReasoningID string  `json:"reasoningID" api:"required"`
	SessionID   string  `json:"sessionID" api:"required"`
	Timestamp   float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ReasoningID respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextRetried 

type GlobalGetEventsResponsePayloadSyncEventSessionNextRetried struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                        `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData `json:"data" api:"required"`
	// Any of "session.next.retried.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextRetried) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextRetried) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextRetried) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextRetried) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData struct {
	Attempt   float64               `json:"attempt" api:"required"`
	Error     SessionNextRetryError `json:"error" api:"required"`
	SessionID string                `json:"sessionID" api:"required"`
	Timestamp float64               `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Attempt     respjson.Field
		Error       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded 

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                           `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData `json:"data" api:"required"`
	// Any of "session.next.shell.ended.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData struct {
	CallID    string  `json:"callID" api:"required"`
	Output    string  `json:"output" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Output      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted 

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                             `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData `json:"data" api:"required"`
	// Any of "session.next.shell.started.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData struct {
	CallID    string  `json:"callID" api:"required"`
	Command   string  `json:"command" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Command     respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                          `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData `json:"data" api:"required"`
	// Any of "session.next.step.ended.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData struct {
	Cost      float64                                                               `json:"cost" api:"required"`
	Finish    string                                                                `json:"finish" api:"required"`
	SessionID string                                                                `json:"sessionID" api:"required"`
	Timestamp float64                                                               `json:"timestamp" api:"required"`
	Tokens    GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens `json:"tokens" api:"required"`
	Snapshot  string                                                                `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cost        respjson.Field
		Finish      respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		Tokens      respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens struct {
	Cache     GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokensCache `json:"cache" api:"required"`
	Input     float64                                                                    `json:"input" api:"required"`
	Output    float64                                                                    `json:"output" api:"required"`
	Reasoning float64                                                                    `json:"reasoning" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokensCache 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokensCache) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokensCache) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokensCache) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                           `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData `json:"data" api:"required"`
	// Any of "session.next.step.failed.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData struct {
	Error     SessionErrorUnknown `json:"error" api:"required"`
	SessionID string              `json:"sessionID" api:"required"`
	Timestamp float64             `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                            `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData `json:"data" api:"required"`
	// Any of "session.next.step.started.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData struct {
	Agent     string                                                                 `json:"agent" api:"required"`
	Model     GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel `json:"model" api:"required"`
	SessionID string                                                                 `json:"sessionID" api:"required"`
	Timestamp float64                                                                `json:"timestamp" api:"required"`
	Snapshot  string                                                                 `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Agent       respjson.Field
		Model       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel 

type GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic 

type GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                          `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData `json:"data" api:"required"`
	// Any of "session.next.synthetic.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta 

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                          `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData `json:"data" api:"required"`
	// Any of "session.next.text.delta.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData struct {
	Delta     string  `json:"delta" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Delta       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded 

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                          `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData `json:"data" api:"required"`
	// Any of "session.next.text.ended.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData struct {
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted 

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                            `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData `json:"data" api:"required"`
	// Any of "session.next.text.started.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData struct {
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                           `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData `json:"data" api:"required"`
	// Any of "session.next.tool.called.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData struct {
	CallID    string                                                                   `json:"callID" api:"required"`
	Input     map[string]any                                                           `json:"input" api:"required"`
	Provider  GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider `json:"provider" api:"required"`
	SessionID string                                                                   `json:"sessionID" api:"required"`
	Timestamp float64                                                                  `json:"timestamp" api:"required"`
	Tool      string                                                                   `json:"tool" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Input       respjson.Field
		Provider    respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		Tool        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider struct {
	Executed bool           `json:"executed" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Executed    respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                           `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData `json:"data" api:"required"`
	// Any of "session.next.tool.failed.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData struct {
	CallID    string                                                                   `json:"callID" api:"required"`
	Error     SessionErrorUnknown                                                      `json:"error" api:"required"`
	Provider  GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider `json:"provider" api:"required"`
	SessionID string                                                                   `json:"sessionID" api:"required"`
	Timestamp float64                                                                  `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Error       respjson.Field
		Provider    respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider struct {
	Executed bool           `json:"executed" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Executed    respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                               `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData `json:"data" api:"required"`
	// Any of "session.next.tool.input.delta.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData struct {
	CallID    string  `json:"callID" api:"required"`
	Delta     string  `json:"delta" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Delta       respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                               `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData `json:"data" api:"required"`
	// Any of "session.next.tool.input.ended.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData struct {
	CallID    string  `json:"callID" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Text      string  `json:"text" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                                 `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData `json:"data" api:"required"`
	// Any of "session.next.tool.input.started.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData struct {
	CallID    string  `json:"callID" api:"required"`
	Name      string  `json:"name" api:"required"`
	SessionID string  `json:"sessionID" api:"required"`
	Timestamp float64 `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Name        respjson.Field
		SessionID   respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                             `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData `json:"data" api:"required"`
	// Any of "session.next.tool.progress.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData struct {
	CallID     string                                                                           `json:"callID" api:"required"`
	Content    []GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion `json:"content" api:"required"`
	SessionID  string                                                                           `json:"sessionID" api:"required"`
	Structured map[string]any                                                                   `json:"structured" api:"required"`
	Timestamp  float64                                                                          `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Content     respjson.Field
		SessionID   respjson.Field
		Structured  respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion struct {
	// This field is from variant [ToolTextContent].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [ToolFileContent].
	Mime string `json:"mime"`
	// This field is from variant [ToolFileContent].
	Uri string `json:"uri"`
	// This field is from variant [ToolFileContent].
	Name string `json:"name"`
	JSON struct {
		Text respjson.Field
		Type respjson.Field
		Mime respjson.Field
		Uri  respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion contains all possible properties and values from ToolTextContent, ToolFileContent.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) AsToolFileContent 

func (u GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) AsToolFileContent() (v ToolFileContent)

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) AsToolTextContent 

func (u GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) AsToolTextContent() (v ToolTextContent)

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) RawJSON 

func (u GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                            `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData `json:"data" api:"required"`
	// Any of "session.next.tool.success.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData struct {
	CallID     string                                                                          `json:"callID" api:"required"`
	Content    []GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion `json:"content" api:"required"`
	Provider   GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider       `json:"provider" api:"required"`
	SessionID  string                                                                          `json:"sessionID" api:"required"`
	Structured map[string]any                                                                  `json:"structured" api:"required"`
	Timestamp  float64                                                                         `json:"timestamp" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		Content     respjson.Field
		Provider    respjson.Field
		SessionID   respjson.Field
		Structured  respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion struct {
	// This field is from variant [ToolTextContent].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [ToolFileContent].
	Mime string `json:"mime"`
	// This field is from variant [ToolFileContent].
	Uri string `json:"uri"`
	// This field is from variant [ToolFileContent].
	Name string `json:"name"`
	JSON struct {
		Text respjson.Field
		Type respjson.Field
		Mime respjson.Field
		Uri  respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion contains all possible properties and values from ToolTextContent, ToolFileContent.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) AsToolFileContent 

func (u GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) AsToolFileContent() (v ToolFileContent)

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) AsToolTextContent 

func (u GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) AsToolTextContent() (v ToolTextContent)

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) RawJSON 

func (u GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider 

type GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider struct {
	Executed bool           `json:"executed" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Executed    respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdated 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdated struct {
	ID string `json:"id" api:"required"`
	// Any of "sessionID".
	AggregateID string                                                    `json:"aggregateID" api:"required"`
	Data        GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData `json:"data" api:"required"`
	// Any of "session.updated.1".
	Name string  `json:"name" api:"required"`
	Seq  float64 `json:"seq" api:"required"`
	// Any of "sync".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdated) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdated) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdated) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdated) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData struct {
	Info      GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo `json:"info" api:"required"`
	SessionID string                                                        `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo struct {
	ID          string                                                               `json:"id" api:"nullable"`
	Agent       string                                                               `json:"agent" api:"nullable"`
	Cost        float64                                                              `json:"cost" api:"nullable"`
	Directory   string                                                               `json:"directory" api:"nullable"`
	Model       GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel   `json:"model" api:"nullable"`
	ParentID    string                                                               `json:"parentID" api:"nullable"`
	Path        string                                                               `json:"path" api:"nullable"`
	Permission  []PermissionRule                                                     `json:"permission" api:"nullable"`
	ProjectID   string                                                               `json:"projectID" api:"nullable"`
	Revert      GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert  `json:"revert" api:"nullable"`
	Share       GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare   `json:"share"`
	Slug        string                                                               `json:"slug" api:"nullable"`
	Summary     GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary `json:"summary" api:"nullable"`
	Time        GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime    `json:"time"`
	Title       string                                                               `json:"title" api:"nullable"`
	Tokens      GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens  `json:"tokens" api:"nullable"`
	Version     string                                                               `json:"version" api:"nullable"`
	WorkspaceID string                                                               `json:"workspaceID" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Agent       respjson.Field
		Cost        respjson.Field
		Directory   respjson.Field
		Model       respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		Permission  respjson.Field
		ProjectID   respjson.Field
		Revert      respjson.Field
		Share       respjson.Field
		Slug        respjson.Field
		Summary     respjson.Field
		Time        respjson.Field
		Title       respjson.Field
		Tokens      respjson.Field
		Version     respjson.Field
		WorkspaceID respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert struct {
	MessageID string `json:"messageID" api:"required"`
	Diff      string `json:"diff"`
	PartID    string `json:"partID"`
	Snapshot  string `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MessageID   respjson.Field
		Diff        respjson.Field
		PartID      respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare struct {
	URL string `json:"url" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary struct {
	Additions float64            `json:"additions" api:"required"`
	Deletions float64            `json:"deletions" api:"required"`
	Files     float64            `json:"files" api:"required"`
	Diffs     []SnapshotFileDiff `json:"diffs"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Additions   respjson.Field
		Deletions   respjson.Field
		Files       respjson.Field
		Diffs       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime struct {
	Archived   float64 `json:"archived" api:"nullable"`
	Compacting int64   `json:"compacting" api:"nullable"`
	Created    int64   `json:"created" api:"nullable"`
	Updated    int64   `json:"updated" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Archived    respjson.Field
		Compacting  respjson.Field
		Created     respjson.Field
		Updated     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens struct {
	Cache     GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache `json:"cache" api:"required"`
	Input     float64                                                                  `json:"input" api:"required"`
	Output    float64                                                                  `json:"output" api:"required"`
	Reasoning float64                                                                  `json:"reasoning" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache 

type GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache) RawJSON 

func (r GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnion 

type GlobalGetEventsResponsePayloadUnion struct {
	ID string `json:"id"`
	// This field is a union of [EventServerInstanceDisposedProperties],
	// [PermissionRequest], [EventPermissionRepliedProperties],
	// [EventLspClientDiagnosticsProperties], [map[string]any],
	// [EventMessagePartDeltaProperties], [EventSessionDiffProperties],
	// [EventSessionErrorProperties], [EventTuiPromptAppendProperties],
	// [EventTuiCommandExecuteProperties],
	// [GlobalGetEventsResponsePayloadEventTuiToastShowProperties],
	// [EventTuiSessionSelectProperties], [EventInstallationUpdatedProperties],
	// [EventInstallationUpdateAvailableProperties], [EventMcpToolsChangedProperties],
	// [EventMcpBrowserOpenFailedProperties], [EventCommandExecutedProperties],
	// [Project], [EventFileEditedProperties], [EventFileWatcherUpdatedProperties],
	// [EventVcsBranchUpdatedProperties], [EventWorktreeReadyProperties],
	// [EventWorktreeFailedProperties], [QuestionRequest],
	// [EventQuestionRepliedProperties], [EventQuestionRejectedProperties],
	// [EventTodoUpdatedProperties], [EventSessionStatusProperties],
	// [EventSessionIdleProperties], [EventSessionCompactedProperties],
	// [EventWorkspaceReadyProperties], [EventWorkspaceFailedProperties],
	// [EventWorkspaceStatusProperties], [EventPtyCreatedProperties],
	// [EventPtyUpdatedProperties], [EventPtyExitedProperties],
	// [EventPtyDeletedProperties], [EventMessageUpdatedProperties],
	// [EventMessageRemovedProperties], [EventMessagePartUpdatedProperties],
	// [EventMessagePartRemovedProperties], [EventSessionCreatedProperties],
	// [EventSessionUpdatedProperties], [EventSessionDeletedProperties],
	// [EventSessionNextAgentSwitchedProperties],
	// [EventSessionNextModelSwitchedProperties], [EventSessionNextPromptedProperties],
	// [EventSessionNextSyntheticProperties], [EventSessionNextShellStartedProperties],
	// [EventSessionNextShellEndedProperties], [EventSessionNextStepStartedProperties],
	// [EventSessionNextStepEndedProperties], [EventSessionNextStepFailedProperties],
	// [EventSessionNextTextStartedProperties], [EventSessionNextTextDeltaProperties],
	// [EventSessionNextTextEndedProperties],
	// [EventSessionNextReasoningStartedProperties],
	// [EventSessionNextReasoningDeltaProperties],
	// [EventSessionNextReasoningEndedProperties],
	// [EventSessionNextToolInputStartedProperties],
	// [EventSessionNextToolInputDeltaProperties],
	// [EventSessionNextToolInputEndedProperties],
	// [EventSessionNextToolCalledProperties],
	// [EventSessionNextToolProgressProperties],
	// [EventSessionNextToolSuccessProperties], [EventSessionNextToolFailedProperties],
	// [EventSessionNextRetriedProperties],
	// [EventSessionNextCompactionStartedProperties],
	// [EventSessionNextCompactionDeltaProperties],
	// [EventSessionNextCompactionEndedProperties], [map[string]any], [map[string]any],
	// [EventCatalogModelUpdatedProperties]
	Properties  GlobalGetEventsResponsePayloadUnionProperties `json:"properties"`
	Type        string                                        `json:"type"`
	AggregateID string                                        `json:"aggregateID"`
	// This field is a union of
	// [GlobalGetEventsResponsePayloadSyncEventMessageUpdatedData],
	// [GlobalGetEventsResponsePayloadSyncEventMessageRemovedData],
	// [GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData],
	// [GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionCreatedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionDeletedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitchedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextSyntheticData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextTextStartedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextTextDeltaData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextTextEndedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStartedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDeltaData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEndedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDeltaData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEndedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDeltaData],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData]
	Data GlobalGetEventsResponsePayloadUnionData `json:"data"`
	Name string                                  `json:"name"`
	Seq  float64                                 `json:"seq"`
	JSON struct {
		ID          respjson.Field
		Properties  respjson.Field
		Type        respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Name        respjson.Field
		Seq         respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnion contains all possible properties and values from EventServerInstanceDisposed, EventPermissionAsked, EventPermissionReplied, EventLspClientDiagnostics, EventLspUpdated, EventMessagePartDelta, EventSessionDiff, EventSessionError, EventTuiPromptAppend, EventTuiCommandExecute, GlobalGetEventsResponsePayloadEventTuiToastShow, EventTuiSessionSelect, EventInstallationUpdated, EventInstallationUpdateAvailable, EventMcpToolsChanged, EventMcpBrowserOpenFailed, EventCommandExecuted, EventProjectUpdated, EventFileEdited, EventFileWatcherUpdated, EventVcsBranchUpdated, EventWorktreeReady, EventWorktreeFailed, EventQuestionAsked, EventQuestionReplied, EventQuestionRejected, EventTodoUpdated, EventSessionStatus, EventSessionIdle, EventSessionCompacted, EventWorkspaceReady, EventWorkspaceFailed, EventWorkspaceStatus, EventPtyCreated, EventPtyUpdated, EventPtyExited, EventPtyDeleted, EventMessageUpdated, EventMessageRemoved, EventMessagePartUpdated, EventMessagePartRemoved, EventSessionCreated, EventSessionUpdated, EventSessionDeleted, EventSessionNextAgentSwitched, EventSessionNextModelSwitched, EventSessionNextPrompted, EventSessionNextSynthetic, EventSessionNextShellStarted, EventSessionNextShellEnded, EventSessionNextStepStarted, EventSessionNextStepEnded, EventSessionNextStepFailed, EventSessionNextTextStarted, EventSessionNextTextDelta, EventSessionNextTextEnded, EventSessionNextReasoningStarted, EventSessionNextReasoningDelta, EventSessionNextReasoningEnded, EventSessionNextToolInputStarted, EventSessionNextToolInputDelta, EventSessionNextToolInputEnded, EventSessionNextToolCalled, EventSessionNextToolProgress, EventSessionNextToolSuccess, EventSessionNextToolFailed, EventSessionNextRetried, EventSessionNextCompactionStarted, EventSessionNextCompactionDelta, EventSessionNextCompactionEnded, EventServerConnected, EventGlobalDisposed, EventCatalogModelUpdated, EventSessionNextAgentSwitched, EventSessionNextModelSwitched, EventSessionNextPrompted, EventSessionNextSynthetic, EventSessionNextShellStarted, EventSessionNextShellEnded, EventSessionNextStepStarted, EventSessionNextStepEnded, EventSessionNextStepFailed, EventSessionNextTextStarted, EventSessionNextTextDelta, EventSessionNextTextEnded, EventSessionNextReasoningStarted, EventSessionNextReasoningDelta, EventSessionNextReasoningEnded, EventSessionNextToolInputStarted, EventSessionNextToolInputDelta, EventSessionNextToolInputEnded, EventSessionNextToolCalled, EventSessionNextToolProgress, EventSessionNextToolSuccess, EventSessionNextToolFailed, EventSessionNextRetried, EventSessionNextCompactionStarted, EventSessionNextCompactionDelta, EventSessionNextCompactionEnded, GlobalGetEventsResponsePayloadSyncEventMessageUpdated, GlobalGetEventsResponsePayloadSyncEventMessageRemoved, GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated, GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved, GlobalGetEventsResponsePayloadSyncEventSessionCreated, GlobalGetEventsResponsePayloadSyncEventSessionUpdated, GlobalGetEventsResponsePayloadSyncEventSessionDeleted, GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched, GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched, GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted, GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic, GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted, GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded, GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted, GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded, GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed, GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted, GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta, GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded, GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted, GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta, GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded, GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted, GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta, GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded, GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled, GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress, GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess, GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed, GlobalGetEventsResponsePayloadSyncEventSessionNextRetried, GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted, GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta, GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (GlobalGetEventsResponsePayloadUnion) AsEventCatalogModelUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventCatalogModelUpdated() (v EventCatalogModelUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventCommandExecuted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventCommandExecuted() (v EventCommandExecuted)

func (GlobalGetEventsResponsePayloadUnion) AsEventFileEdited 

func (u GlobalGetEventsResponsePayloadUnion) AsEventFileEdited() (v EventFileEdited)

func (GlobalGetEventsResponsePayloadUnion) AsEventFileWatcherUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventFileWatcherUpdated() (v EventFileWatcherUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventGlobalDisposed 

func (u GlobalGetEventsResponsePayloadUnion) AsEventGlobalDisposed() (v EventGlobalDisposed)

func (GlobalGetEventsResponsePayloadUnion) AsEventInstallationUpdateAvailable 

func (u GlobalGetEventsResponsePayloadUnion) AsEventInstallationUpdateAvailable() (v EventInstallationUpdateAvailable)

func (GlobalGetEventsResponsePayloadUnion) AsEventInstallationUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventInstallationUpdated() (v EventInstallationUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventLspClientDiagnostics 

func (u GlobalGetEventsResponsePayloadUnion) AsEventLspClientDiagnostics() (v EventLspClientDiagnostics)

func (GlobalGetEventsResponsePayloadUnion) AsEventLspUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventLspUpdated() (v EventLspUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventMcpBrowserOpenFailed 

func (u GlobalGetEventsResponsePayloadUnion) AsEventMcpBrowserOpenFailed() (v EventMcpBrowserOpenFailed)

func (GlobalGetEventsResponsePayloadUnion) AsEventMcpToolsChanged 

func (u GlobalGetEventsResponsePayloadUnion) AsEventMcpToolsChanged() (v EventMcpToolsChanged)

func (GlobalGetEventsResponsePayloadUnion) AsEventMessagePartDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsEventMessagePartDelta() (v EventMessagePartDelta)

func (GlobalGetEventsResponsePayloadUnion) AsEventMessagePartRemoved 

func (u GlobalGetEventsResponsePayloadUnion) AsEventMessagePartRemoved() (v EventMessagePartRemoved)

func (GlobalGetEventsResponsePayloadUnion) AsEventMessagePartUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventMessagePartUpdated() (v EventMessagePartUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventMessageRemoved 

func (u GlobalGetEventsResponsePayloadUnion) AsEventMessageRemoved() (v EventMessageRemoved)

func (GlobalGetEventsResponsePayloadUnion) AsEventMessageUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventMessageUpdated() (v EventMessageUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventPermissionAsked 

func (u GlobalGetEventsResponsePayloadUnion) AsEventPermissionAsked() (v EventPermissionAsked)

func (GlobalGetEventsResponsePayloadUnion) AsEventPermissionReplied 

func (u GlobalGetEventsResponsePayloadUnion) AsEventPermissionReplied() (v EventPermissionReplied)

func (GlobalGetEventsResponsePayloadUnion) AsEventProjectUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventProjectUpdated() (v EventProjectUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventPtyCreated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventPtyCreated() (v EventPtyCreated)

func (GlobalGetEventsResponsePayloadUnion) AsEventPtyDeleted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventPtyDeleted() (v EventPtyDeleted)

func (GlobalGetEventsResponsePayloadUnion) AsEventPtyExited 

func (u GlobalGetEventsResponsePayloadUnion) AsEventPtyExited() (v EventPtyExited)

func (GlobalGetEventsResponsePayloadUnion) AsEventPtyUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventPtyUpdated() (v EventPtyUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventQuestionAsked 

func (u GlobalGetEventsResponsePayloadUnion) AsEventQuestionAsked() (v EventQuestionAsked)

func (GlobalGetEventsResponsePayloadUnion) AsEventQuestionRejected 

func (u GlobalGetEventsResponsePayloadUnion) AsEventQuestionRejected() (v EventQuestionRejected)

func (GlobalGetEventsResponsePayloadUnion) AsEventQuestionReplied 

func (u GlobalGetEventsResponsePayloadUnion) AsEventQuestionReplied() (v EventQuestionReplied)

func (GlobalGetEventsResponsePayloadUnion) AsEventServerConnected 

func (u GlobalGetEventsResponsePayloadUnion) AsEventServerConnected() (v EventServerConnected)

func (GlobalGetEventsResponsePayloadUnion) AsEventServerInstanceDisposed 

func (u GlobalGetEventsResponsePayloadUnion) AsEventServerInstanceDisposed() (v EventServerInstanceDisposed)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionCompacted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionCompacted() (v EventSessionCompacted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionCreated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionCreated() (v EventSessionCreated)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionDeleted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionDeleted() (v EventSessionDeleted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionDiff 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionDiff() (v EventSessionDiff)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionError 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionError() (v EventSessionError)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionIdle 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionIdle() (v EventSessionIdle)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextAgentSwitched 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextAgentSwitched() (v EventSessionNextAgentSwitched)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextCompactionDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextCompactionDelta() (v EventSessionNextCompactionDelta)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextCompactionEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextCompactionEnded() (v EventSessionNextCompactionEnded)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextCompactionStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextCompactionStarted() (v EventSessionNextCompactionStarted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextModelSwitched 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextModelSwitched() (v EventSessionNextModelSwitched)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextPrompted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextPrompted() (v EventSessionNextPrompted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextReasoningDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextReasoningDelta() (v EventSessionNextReasoningDelta)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextReasoningEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextReasoningEnded() (v EventSessionNextReasoningEnded)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextReasoningStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextReasoningStarted() (v EventSessionNextReasoningStarted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextRetried 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextRetried() (v EventSessionNextRetried)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextShellEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextShellEnded() (v EventSessionNextShellEnded)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextShellStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextShellStarted() (v EventSessionNextShellStarted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextStepEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextStepEnded() (v EventSessionNextStepEnded)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextStepFailed 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextStepFailed() (v EventSessionNextStepFailed)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextStepStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextStepStarted() (v EventSessionNextStepStarted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextSynthetic 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextSynthetic() (v EventSessionNextSynthetic)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextTextDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextTextDelta() (v EventSessionNextTextDelta)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextTextEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextTextEnded() (v EventSessionNextTextEnded)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextTextStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextTextStarted() (v EventSessionNextTextStarted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolCalled 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolCalled() (v EventSessionNextToolCalled)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolFailed 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolFailed() (v EventSessionNextToolFailed)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolInputDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolInputDelta() (v EventSessionNextToolInputDelta)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolInputEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolInputEnded() (v EventSessionNextToolInputEnded)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolInputStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolInputStarted() (v EventSessionNextToolInputStarted)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolProgress 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolProgress() (v EventSessionNextToolProgress)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolSuccess 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionNextToolSuccess() (v EventSessionNextToolSuccess)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionStatus 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionStatus() (v EventSessionStatus)

func (GlobalGetEventsResponsePayloadUnion) AsEventSessionUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventSessionUpdated() (v EventSessionUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventTodoUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventTodoUpdated() (v EventTodoUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventTuiCommandExecute 

func (u GlobalGetEventsResponsePayloadUnion) AsEventTuiCommandExecute() (v EventTuiCommandExecute)

func (GlobalGetEventsResponsePayloadUnion) AsEventTuiPromptAppend 

func (u GlobalGetEventsResponsePayloadUnion) AsEventTuiPromptAppend() (v EventTuiPromptAppend)

func (GlobalGetEventsResponsePayloadUnion) AsEventTuiSessionSelect 

func (u GlobalGetEventsResponsePayloadUnion) AsEventTuiSessionSelect() (v EventTuiSessionSelect)

func (GlobalGetEventsResponsePayloadUnion) AsEventVcsBranchUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsEventVcsBranchUpdated() (v EventVcsBranchUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsEventWorkspaceFailed 

func (u GlobalGetEventsResponsePayloadUnion) AsEventWorkspaceFailed() (v EventWorkspaceFailed)

func (GlobalGetEventsResponsePayloadUnion) AsEventWorkspaceReady 

func (u GlobalGetEventsResponsePayloadUnion) AsEventWorkspaceReady() (v EventWorkspaceReady)

func (GlobalGetEventsResponsePayloadUnion) AsEventWorkspaceStatus 

func (u GlobalGetEventsResponsePayloadUnion) AsEventWorkspaceStatus() (v EventWorkspaceStatus)

func (GlobalGetEventsResponsePayloadUnion) AsEventWorktreeFailed 

func (u GlobalGetEventsResponsePayloadUnion) AsEventWorktreeFailed() (v EventWorktreeFailed)

func (GlobalGetEventsResponsePayloadUnion) AsEventWorktreeReady 

func (u GlobalGetEventsResponsePayloadUnion) AsEventWorktreeReady() (v EventWorktreeReady)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadEventTuiToastShow 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadEventTuiToastShow() (v GlobalGetEventsResponsePayloadEventTuiToastShow)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessagePartRemoved 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessagePartRemoved() (v GlobalGetEventsResponsePayloadSyncEventMessagePartRemoved)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessagePartUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessagePartUpdated() (v GlobalGetEventsResponsePayloadSyncEventMessagePartUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessageRemoved 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessageRemoved() (v GlobalGetEventsResponsePayloadSyncEventMessageRemoved)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessageUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventMessageUpdated() (v GlobalGetEventsResponsePayloadSyncEventMessageUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionCreated 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionCreated() (v GlobalGetEventsResponsePayloadSyncEventSessionCreated)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionDeleted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionDeleted() (v GlobalGetEventsResponsePayloadSyncEventSessionDeleted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched() (v GlobalGetEventsResponsePayloadSyncEventSessionNextAgentSwitched)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta() (v GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionDelta)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded() (v GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEnded)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted() (v GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStarted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched() (v GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitched)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextPrompted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextPrompted() (v GlobalGetEventsResponsePayloadSyncEventSessionNextPrompted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta() (v GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningDelta)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded() (v GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningEnded)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted() (v GlobalGetEventsResponsePayloadSyncEventSessionNextReasoningStarted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextRetried 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextRetried() (v GlobalGetEventsResponsePayloadSyncEventSessionNextRetried)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded() (v GlobalGetEventsResponsePayloadSyncEventSessionNextShellEnded)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted() (v GlobalGetEventsResponsePayloadSyncEventSessionNextShellStarted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded() (v GlobalGetEventsResponsePayloadSyncEventSessionNextStepEnded)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed() (v GlobalGetEventsResponsePayloadSyncEventSessionNextStepFailed)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted() (v GlobalGetEventsResponsePayloadSyncEventSessionNextStepStarted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic() (v GlobalGetEventsResponsePayloadSyncEventSessionNextSynthetic)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta() (v GlobalGetEventsResponsePayloadSyncEventSessionNextTextDelta)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded() (v GlobalGetEventsResponsePayloadSyncEventSessionNextTextEnded)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted() (v GlobalGetEventsResponsePayloadSyncEventSessionNextTextStarted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled() (v GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalled)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed() (v GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailed)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta() (v GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputDelta)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded() (v GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputEnded)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted() (v GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStarted)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress() (v GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgress)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess() (v GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccess)

func (GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionUpdated 

func (u GlobalGetEventsResponsePayloadUnion) AsGlobalGetEventsResponsePayloadSyncEventSessionUpdated() (v GlobalGetEventsResponsePayloadSyncEventSessionUpdated)

func (GlobalGetEventsResponsePayloadUnion) AsVariant2 

func (u GlobalGetEventsResponsePayloadUnion) AsVariant2() (v EventSessionNextAgentSwitched)

func (GlobalGetEventsResponsePayloadUnion) AsVariant3 

func (u GlobalGetEventsResponsePayloadUnion) AsVariant3() (v EventSessionNextCompactionEnded)

func (GlobalGetEventsResponsePayloadUnion) RawJSON 

func (u GlobalGetEventsResponsePayloadUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetEventsResponsePayloadUnion) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnion) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionData 

type GlobalGetEventsResponsePayloadUnionData struct {
	// This field is a union of [MessageUnion], [Session],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfo]
	Info      GlobalGetEventsResponsePayloadUnionDataInfo `json:"info"`
	SessionID string                                      `json:"sessionID"`
	MessageID string                                      `json:"messageID"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData].
	Part PartUnion `json:"part"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventMessagePartUpdatedData].
	Time int64 `json:"time"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventMessagePartRemovedData].
	PartID    string  `json:"partID"`
	Agent     string  `json:"agent"`
	Timestamp float64 `json:"timestamp"`
	// This field is a union of
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextModelSwitchedDataModel],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextStepStartedDataModel]
	Model GlobalGetEventsResponsePayloadUnionDataModel `json:"model"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextPromptedData].
	Prompt Prompt `json:"prompt"`
	Text   string `json:"text"`
	CallID string `json:"callID"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextShellStartedData].
	Command string `json:"command"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextShellEndedData].
	Output   string `json:"output"`
	Snapshot string `json:"snapshot"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData].
	Cost float64 `json:"cost"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData].
	Finish string `json:"finish"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedData].
	Tokens GlobalGetEventsResponsePayloadSyncEventSessionNextStepEndedDataTokens `json:"tokens"`
	// This field is a union of [SessionErrorUnknown], [SessionNextRetryError]
	Error       GlobalGetEventsResponsePayloadUnionDataError `json:"error"`
	Delta       string                                       `json:"delta"`
	ReasoningID string                                       `json:"reasoningID"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolInputStartedData].
	Name string `json:"name"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData].
	Input map[string]any `json:"input"`
	// This field is a union of
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledDataProvider],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataProvider],
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolFailedDataProvider]
	Provider GlobalGetEventsResponsePayloadUnionDataProvider `json:"provider"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextToolCalledData].
	Tool string `json:"tool"`
	// This field is a union of
	// [[]GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion],
	// [[]GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion]
	Content    GlobalGetEventsResponsePayloadUnionDataContent `json:"content"`
	Structured any                                            `json:"structured"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextRetriedData].
	Attempt float64 `json:"attempt"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionStartedData].
	Reason string `json:"reason"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadSyncEventSessionNextCompactionEndedData].
	Include string `json:"include"`
	JSON    struct {
		Info        respjson.Field
		SessionID   respjson.Field
		MessageID   respjson.Field
		Part        respjson.Field
		Time        respjson.Field
		PartID      respjson.Field
		Agent       respjson.Field
		Timestamp   respjson.Field
		Model       respjson.Field
		Prompt      respjson.Field
		Text        respjson.Field
		CallID      respjson.Field
		Command     respjson.Field
		Output      respjson.Field
		Snapshot    respjson.Field
		Cost        respjson.Field
		Finish      respjson.Field
		Tokens      respjson.Field
		Error       respjson.Field
		Delta       respjson.Field
		ReasoningID respjson.Field
		Name        respjson.Field
		Input       respjson.Field
		Provider    respjson.Field
		Tool        respjson.Field
		Content     respjson.Field
		Structured  respjson.Field
		Attempt     respjson.Field
		Reason      respjson.Field
		Include     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionData is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionData provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataContent 

type GlobalGetEventsResponsePayloadUnionDataContent struct {
	// This field will be present if the value is a
	// [[]GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion]
	// instead of an object.
	OfGlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentArray []GlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentUnion `json:",inline"`
	// This field will be present if the value is a
	// [[]GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion]
	// instead of an object.
	OfGlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentArray []GlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentUnion `json:",inline"`
	JSON                                                                            struct {
		OfGlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentArray respjson.Field
		OfGlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentArray  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataContent is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataContent provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfGlobalGetEventsResponsePayloadSyncEventSessionNextToolProgressDataContentArray OfGlobalGetEventsResponsePayloadSyncEventSessionNextToolSuccessDataContentArray]

func (*GlobalGetEventsResponsePayloadUnionDataContent) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataContent) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataError 

type GlobalGetEventsResponsePayloadUnionDataError struct {
	Message string `json:"message"`
	// This field is from variant [SessionErrorUnknown].
	Type SessionErrorUnknownType `json:"type"`
	// This field is from variant [SessionNextRetryError].
	IsRetryable bool `json:"isRetryable"`
	// This field is from variant [SessionNextRetryError].
	Metadata map[string]string `json:"metadata"`
	// This field is from variant [SessionNextRetryError].
	ResponseBody string `json:"responseBody"`
	// This field is from variant [SessionNextRetryError].
	ResponseHeaders map[string]string `json:"responseHeaders"`
	// This field is from variant [SessionNextRetryError].
	StatusCode float64 `json:"statusCode"`
	JSON       struct {
		Message         respjson.Field
		Type            respjson.Field
		IsRetryable     respjson.Field
		Metadata        respjson.Field
		ResponseBody    respjson.Field
		ResponseHeaders respjson.Field
		StatusCode      respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataError is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataError provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataError) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataError) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfo 

type GlobalGetEventsResponsePayloadUnionDataInfo struct {
	ID    string `json:"id"`
	Agent string `json:"agent"`
	// This field is a union of [MessageUserMessageModel], [SessionModel],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoModel]
	Model     GlobalGetEventsResponsePayloadUnionDataInfoModel `json:"model"`
	Role      string                                           `json:"role"`
	SessionID string                                           `json:"sessionID"`
	// This field is a union of [MessageUserMessageTime], [AssistantMessageTime],
	// [SessionTime],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTime]
	Time GlobalGetEventsResponsePayloadUnionDataInfoTime `json:"time"`
	// This field is from variant [MessageUnion].
	Format OutputFormatUnion `json:"format"`
	// This field is a union of [MessageUserMessageSummary], [bool], [SessionSummary],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoSummary]
	Summary GlobalGetEventsResponsePayloadUnionDataInfoSummary `json:"summary"`
	// This field is from variant [MessageUnion].
	System string `json:"system"`
	// This field is from variant [MessageUnion].
	Tools map[string]bool `json:"tools"`
	Cost  float64         `json:"cost"`
	// This field is from variant [MessageUnion].
	Mode string `json:"mode"`
	// This field is from variant [MessageUnion].
	ModelID  string `json:"modelID"`
	ParentID string `json:"parentID"`
	// This field is a union of [AssistantMessagePath], [string], [string]
	Path GlobalGetEventsResponsePayloadUnionDataInfoPath `json:"path"`
	// This field is from variant [MessageUnion].
	ProviderID string `json:"providerID"`
	// This field is a union of [AssistantMessageTokens], [SessionTokens],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokens]
	Tokens GlobalGetEventsResponsePayloadUnionDataInfoTokens `json:"tokens"`
	// This field is from variant [MessageUnion].
	Error AssistantMessageErrorUnion `json:"error"`
	// This field is from variant [MessageUnion].
	Finish string `json:"finish"`
	// This field is from variant [MessageUnion].
	Structured any `json:"structured"`
	// This field is from variant [MessageUnion].
	Variant    string           `json:"variant"`
	Directory  string           `json:"directory"`
	ProjectID  string           `json:"projectID"`
	Slug       string           `json:"slug"`
	Title      string           `json:"title"`
	Version    string           `json:"version"`
	Permission []PermissionRule `json:"permission"`
	// This field is a union of [SessionRevert],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoRevert]
	Revert GlobalGetEventsResponsePayloadUnionDataInfoRevert `json:"revert"`
	// This field is a union of [SessionShare],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoShare]
	Share       GlobalGetEventsResponsePayloadUnionDataInfoShare `json:"share"`
	WorkspaceID string                                           `json:"workspaceID"`
	JSON        struct {
		ID          respjson.Field
		Agent       respjson.Field
		Model       respjson.Field
		Role        respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		Format      respjson.Field
		Summary     respjson.Field
		System      respjson.Field
		Tools       respjson.Field
		Cost        respjson.Field
		Mode        respjson.Field
		ModelID     respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		ProviderID  respjson.Field
		Tokens      respjson.Field
		Error       respjson.Field
		Finish      respjson.Field
		Structured  respjson.Field
		Variant     respjson.Field
		Directory   respjson.Field
		ProjectID   respjson.Field
		Slug        respjson.Field
		Title       respjson.Field
		Version     respjson.Field
		Permission  respjson.Field
		Revert      respjson.Field
		Share       respjson.Field
		WorkspaceID respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfo is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfo provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataInfo) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfo) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoModel 

type GlobalGetEventsResponsePayloadUnionDataInfoModel struct {
	// This field is from variant [MessageUserMessageModel].
	ModelID    string `json:"modelID"`
	ProviderID string `json:"providerID"`
	Variant    string `json:"variant"`
	ID         string `json:"id"`
	JSON       struct {
		ModelID    respjson.Field
		ProviderID respjson.Field
		Variant    respjson.Field
		ID         respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoModel is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoModel provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataInfoModel) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoModel) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoPath 

type GlobalGetEventsResponsePayloadUnionDataInfoPath struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field is from variant [AssistantMessagePath].
	Cwd string `json:"cwd"`
	// This field is from variant [AssistantMessagePath].
	Root string `json:"root"`
	JSON struct {
		OfString respjson.Field
		Cwd      respjson.Field
		Root     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoPath is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoPath provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfString]

func (*GlobalGetEventsResponsePayloadUnionDataInfoPath) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoPath) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoRevert 

type GlobalGetEventsResponsePayloadUnionDataInfoRevert struct {
	MessageID string `json:"messageID"`
	Diff      string `json:"diff"`
	PartID    string `json:"partID"`
	Snapshot  string `json:"snapshot"`
	JSON      struct {
		MessageID respjson.Field
		Diff      respjson.Field
		PartID    respjson.Field
		Snapshot  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoRevert is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoRevert provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataInfoRevert) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoRevert) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoShare 

type GlobalGetEventsResponsePayloadUnionDataInfoShare struct {
	URL  string `json:"url"`
	JSON struct {
		URL respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoShare is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoShare provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataInfoShare) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoShare) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoSummary 

type GlobalGetEventsResponsePayloadUnionDataInfoSummary struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool bool               `json:",inline"`
	Diffs  []SnapshotFileDiff `json:"diffs"`
	// This field is from variant [MessageUserMessageSummary].
	Body string `json:"body"`
	// This field is from variant [MessageUserMessageSummary].
	Title     string  `json:"title"`
	Additions float64 `json:"additions"`
	Deletions float64 `json:"deletions"`
	Files     float64 `json:"files"`
	JSON      struct {
		OfBool    respjson.Field
		Diffs     respjson.Field
		Body      respjson.Field
		Title     respjson.Field
		Additions respjson.Field
		Deletions respjson.Field
		Files     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoSummary is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoSummary provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfBool]

func (*GlobalGetEventsResponsePayloadUnionDataInfoSummary) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoSummary) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoTime 

type GlobalGetEventsResponsePayloadUnionDataInfoTime struct {
	Created int64 `json:"created"`
	// This field is from variant [AssistantMessageTime].
	Completed  int64   `json:"completed"`
	Updated    int64   `json:"updated"`
	Archived   float64 `json:"archived"`
	Compacting int64   `json:"compacting"`
	JSON       struct {
		Created    respjson.Field
		Completed  respjson.Field
		Updated    respjson.Field
		Archived   respjson.Field
		Compacting respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoTime is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataInfoTime) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoTime) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoTokens 

type GlobalGetEventsResponsePayloadUnionDataInfoTokens struct {
	// This field is a union of [AssistantMessageTokensCache], [SessionTokensCache],
	// [GlobalGetEventsResponsePayloadSyncEventSessionUpdatedDataInfoTokensCache]
	Cache     GlobalGetEventsResponsePayloadUnionDataInfoTokensCache `json:"cache"`
	Input     float64                                                `json:"input"`
	Output    float64                                                `json:"output"`
	Reasoning float64                                                `json:"reasoning"`
	// This field is from variant [AssistantMessageTokens].
	Total float64 `json:"total"`
	JSON  struct {
		Cache     respjson.Field
		Input     respjson.Field
		Output    respjson.Field
		Reasoning respjson.Field
		Total     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoTokens is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoTokens provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataInfoTokens) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoTokens) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataInfoTokensCache 

type GlobalGetEventsResponsePayloadUnionDataInfoTokensCache struct {
	Read  float64 `json:"read"`
	Write float64 `json:"write"`
	JSON  struct {
		Read  respjson.Field
		Write respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataInfoTokensCache is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataInfoTokensCache provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataInfoTokensCache) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataInfoTokensCache) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataModel 

type GlobalGetEventsResponsePayloadUnionDataModel struct {
	ID         string `json:"id"`
	ProviderID string `json:"providerID"`
	Variant    string `json:"variant"`
	JSON       struct {
		ID         respjson.Field
		ProviderID respjson.Field
		Variant    respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataModel is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataModel provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataModel) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataModel) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionDataProvider 

type GlobalGetEventsResponsePayloadUnionDataProvider struct {
	Executed bool `json:"executed"`
	Metadata any  `json:"metadata"`
	JSON     struct {
		Executed respjson.Field
		Metadata respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionDataProvider is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionDataProvider provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionDataProvider) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionDataProvider) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionProperties 

type GlobalGetEventsResponsePayloadUnionProperties struct {
	// This field will be present if the value is a [any] instead of an object.
	OfEventGlobalDisposedProperty any `json:",inline"`
	// This field is from variant [EventServerInstanceDisposedProperties].
	Directory string `json:"directory"`
	ID        string `json:"id"`
	// This field is from variant [PermissionRequest].
	Always []string `json:"always"`
	// This field is from variant [PermissionRequest].
	Metadata map[string]any `json:"metadata"`
	// This field is from variant [PermissionRequest].
	Patterns []string `json:"patterns"`
	// This field is from variant [PermissionRequest].
	Permission string `json:"permission"`
	SessionID  string `json:"sessionID"`
	// This field is a union of [PermissionRequestTool], [QuestionRequestTool],
	// [string]
	Tool GlobalGetEventsResponsePayloadUnionPropertiesTool `json:"tool"`
	// This field is from variant [EventPermissionRepliedProperties].
	Reply     string `json:"reply"`
	RequestID string `json:"requestID"`
	// This field is from variant [EventLspClientDiagnosticsProperties].
	Path string `json:"path"`
	// This field is from variant [EventLspClientDiagnosticsProperties].
	ServerID string `json:"serverID"`
	Delta    string `json:"delta"`
	// This field is from variant [EventMessagePartDeltaProperties].
	Field     string `json:"field"`
	MessageID string `json:"messageID"`
	PartID    string `json:"partID"`
	// This field is from variant [EventSessionDiffProperties].
	Diff []SnapshotFileDiff `json:"diff"`
	// This field is a union of [EventSessionErrorPropertiesErrorUnion],
	// [SessionErrorUnknown], [SessionNextRetryError]
	Error   GlobalGetEventsResponsePayloadUnionPropertiesError `json:"error"`
	Text    string                                             `json:"text"`
	Command string                                             `json:"command"`
	Message string                                             `json:"message"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadEventTuiToastShowProperties].
	Variant string `json:"variant"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadEventTuiToastShowProperties].
	Duration int64 `json:"duration"`
	// This field is from variant
	// [GlobalGetEventsResponsePayloadEventTuiToastShowProperties].
	Title   string `json:"title"`
	Version string `json:"version"`
	// This field is from variant [EventMcpToolsChangedProperties].
	Server string `json:"server"`
	// This field is from variant [EventMcpBrowserOpenFailedProperties].
	McpName string `json:"mcpName"`
	// This field is from variant [EventMcpBrowserOpenFailedProperties].
	URL string `json:"url"`
	// This field is from variant [EventCommandExecutedProperties].
	Arguments string `json:"arguments"`
	Name      string `json:"name"`
	// This field is from variant [Project].
	Sandboxes []string `json:"sandboxes"`
	// This field is a union of [ProjectTime], [int64]
	Time GlobalGetEventsResponsePayloadUnionPropertiesTime `json:"time"`
	// This field is from variant [Project].
	Worktree string `json:"worktree"`
	// This field is from variant [Project].
	Commands ProjectCommands `json:"commands"`
	// This field is from variant [Project].
	Icon ProjectIcon `json:"icon"`
	// This field is from variant [Project].
	Vcs  ProjectVcs `json:"vcs"`
	File string     `json:"file"`
	// This field is from variant [EventFileWatcherUpdatedProperties].
	Event  string `json:"event"`
	Branch string `json:"branch"`
	// This field is from variant [QuestionRequest].
	Questions []QuestionRequestQuestion `json:"questions"`
	// This field is from variant [EventQuestionRepliedProperties].
	Answers [][]string `json:"answers"`
	// This field is from variant [EventTodoUpdatedProperties].
	Todos []Todo `json:"todos"`
	// This field is a union of [EventSessionStatusPropertiesStatusUnion], [string]
	Status GlobalGetEventsResponsePayloadUnionPropertiesStatus `json:"status"`
	// This field is from variant [EventWorkspaceStatusProperties].
	WorkspaceID string `json:"workspaceID"`
	// This field is a union of [Pty], [MessageUnion], [Session]
	Info GlobalGetEventsResponsePayloadUnionPropertiesInfo `json:"info"`
	// This field is from variant [EventPtyExitedProperties].
	ExitCode int64 `json:"exitCode"`
	// This field is from variant [EventMessagePartUpdatedProperties].
	Part      PartUnion `json:"part"`
	Agent     string    `json:"agent"`
	Timestamp float64   `json:"timestamp"`
	// This field is a union of [EventSessionNextModelSwitchedPropertiesModel],
	// [EventSessionNextStepStartedPropertiesModel], [ModelV2Info]
	Model GlobalGetEventsResponsePayloadUnionPropertiesModel `json:"model"`
	// This field is from variant [EventSessionNextPromptedProperties].
	Prompt Prompt `json:"prompt"`
	CallID string `json:"callID"`
	// This field is from variant [EventSessionNextShellEndedProperties].
	Output   string `json:"output"`
	Snapshot string `json:"snapshot"`
	// This field is from variant [EventSessionNextStepEndedProperties].
	Cost float64 `json:"cost"`
	// This field is from variant [EventSessionNextStepEndedProperties].
	Finish string `json:"finish"`
	// This field is from variant [EventSessionNextStepEndedProperties].
	Tokens      EventSessionNextStepEndedPropertiesTokens `json:"tokens"`
	ReasoningID string                                    `json:"reasoningID"`
	// This field is from variant [EventSessionNextToolCalledProperties].
	Input map[string]any `json:"input"`
	// This field is a union of [EventSessionNextToolCalledPropertiesProvider],
	// [EventSessionNextToolSuccessPropertiesProvider],
	// [EventSessionNextToolFailedPropertiesProvider]
	Provider GlobalGetEventsResponsePayloadUnionPropertiesProvider `json:"provider"`
	// This field is a union of [[]EventSessionNextToolProgressPropertiesContentUnion],
	// [[]EventSessionNextToolSuccessPropertiesContentUnion]
	Content    GlobalGetEventsResponsePayloadUnionPropertiesContent `json:"content"`
	Structured any                                                  `json:"structured"`
	// This field is from variant [EventSessionNextRetriedProperties].
	Attempt float64 `json:"attempt"`
	// This field is from variant [EventSessionNextCompactionStartedProperties].
	Reason string `json:"reason"`
	// This field is from variant [EventSessionNextCompactionEndedProperties].
	Include string `json:"include"`
	JSON    struct {
		OfEventGlobalDisposedProperty respjson.Field
		Directory                     respjson.Field
		ID                            respjson.Field
		Always                        respjson.Field
		Metadata                      respjson.Field
		Patterns                      respjson.Field
		Permission                    respjson.Field
		SessionID                     respjson.Field
		Tool                          respjson.Field
		Reply                         respjson.Field
		RequestID                     respjson.Field
		Path                          respjson.Field
		ServerID                      respjson.Field
		Delta                         respjson.Field
		Field                         respjson.Field
		MessageID                     respjson.Field
		PartID                        respjson.Field
		Diff                          respjson.Field
		Error                         respjson.Field
		Text                          respjson.Field
		Command                       respjson.Field
		Message                       respjson.Field
		Variant                       respjson.Field
		Duration                      respjson.Field
		Title                         respjson.Field
		Version                       respjson.Field
		Server                        respjson.Field
		McpName                       respjson.Field
		URL                           respjson.Field
		Arguments                     respjson.Field
		Name                          respjson.Field
		Sandboxes                     respjson.Field
		Time                          respjson.Field
		Worktree                      respjson.Field
		Commands                      respjson.Field
		Icon                          respjson.Field
		Vcs                           respjson.Field
		File                          respjson.Field
		Event                         respjson.Field
		Branch                        respjson.Field
		Questions                     respjson.Field
		Answers                       respjson.Field
		Todos                         respjson.Field
		Status                        respjson.Field
		WorkspaceID                   respjson.Field
		Info                          respjson.Field
		ExitCode                      respjson.Field
		Part                          respjson.Field
		Agent                         respjson.Field
		Timestamp                     respjson.Field
		Model                         respjson.Field
		Prompt                        respjson.Field
		CallID                        respjson.Field
		Output                        respjson.Field
		Snapshot                      respjson.Field
		Cost                          respjson.Field
		Finish                        respjson.Field
		Tokens                        respjson.Field
		ReasoningID                   respjson.Field
		Input                         respjson.Field
		Provider                      respjson.Field
		Content                       respjson.Field
		Structured                    respjson.Field
		Attempt                       respjson.Field
		Reason                        respjson.Field
		Include                       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionProperties is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionProperties provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfEventGlobalDisposedProperty]

func (*GlobalGetEventsResponsePayloadUnionProperties) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionProperties) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesContent 

type GlobalGetEventsResponsePayloadUnionPropertiesContent struct {
	// This field will be present if the value is a
	// [[]EventSessionNextToolProgressPropertiesContentUnion] instead of an object.
	OfEventSessionNextToolProgressPropertiesContentArray []EventSessionNextToolProgressPropertiesContentUnion `json:",inline"`
	// This field will be present if the value is a
	// [[]EventSessionNextToolSuccessPropertiesContentUnion] instead of an object.
	OfEventSessionNextToolSuccessPropertiesContentArray []EventSessionNextToolSuccessPropertiesContentUnion `json:",inline"`
	JSON                                                struct {
		OfEventSessionNextToolProgressPropertiesContentArray respjson.Field
		OfEventSessionNextToolSuccessPropertiesContentArray  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesContent is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesContent provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfEventSessionNextToolProgressPropertiesContentArray OfEventSessionNextToolSuccessPropertiesContentArray]

func (*GlobalGetEventsResponsePayloadUnionPropertiesContent) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesContent) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesError 

type GlobalGetEventsResponsePayloadUnionPropertiesError struct {
	// This field is a union of [ProviderAuthErrorData], [UnknownErrorData],
	// [map[string]any], [MessageAbortedErrorData], [StructuredOutputErrorData],
	// [ContextOverflowErrorData], [APIErrorData]
	Data    GlobalGetEventsResponsePayloadUnionPropertiesErrorData `json:"data"`
	Name    string                                                 `json:"name"`
	Message string                                                 `json:"message"`
	// This field is from variant [SessionErrorUnknown].
	Type SessionErrorUnknownType `json:"type"`
	// This field is from variant [SessionNextRetryError].
	IsRetryable bool `json:"isRetryable"`
	// This field is from variant [SessionNextRetryError].
	Metadata map[string]string `json:"metadata"`
	// This field is from variant [SessionNextRetryError].
	ResponseBody string `json:"responseBody"`
	// This field is from variant [SessionNextRetryError].
	ResponseHeaders map[string]string `json:"responseHeaders"`
	// This field is from variant [SessionNextRetryError].
	StatusCode float64 `json:"statusCode"`
	JSON       struct {
		Data            respjson.Field
		Name            respjson.Field
		Message         respjson.Field
		Type            respjson.Field
		IsRetryable     respjson.Field
		Metadata        respjson.Field
		ResponseBody    respjson.Field
		ResponseHeaders respjson.Field
		StatusCode      respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesError is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesError provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesError) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesError) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesErrorData 

type GlobalGetEventsResponsePayloadUnionPropertiesErrorData struct {
	// This field will be present if the value is a [any] instead of an object.
	OfMessageOutputLengthErrorData any    `json:",inline"`
	Message                        string `json:"message"`
	// This field is from variant [ProviderAuthErrorData].
	ProviderID string `json:"providerID"`
	// This field is from variant [StructuredOutputErrorData].
	Retries      int64  `json:"retries"`
	ResponseBody string `json:"responseBody"`
	// This field is from variant [APIErrorData].
	IsRetryable bool `json:"isRetryable"`
	// This field is from variant [APIErrorData].
	Metadata map[string]string `json:"metadata"`
	// This field is from variant [APIErrorData].
	ResponseHeaders map[string]string `json:"responseHeaders"`
	// This field is from variant [APIErrorData].
	StatusCode int64 `json:"statusCode"`
	JSON       struct {
		OfMessageOutputLengthErrorData respjson.Field
		Message                        respjson.Field
		ProviderID                     respjson.Field
		Retries                        respjson.Field
		ResponseBody                   respjson.Field
		IsRetryable                    respjson.Field
		Metadata                       respjson.Field
		ResponseHeaders                respjson.Field
		StatusCode                     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesErrorData is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesErrorData provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfMessageOutputLengthErrorData]

func (*GlobalGetEventsResponsePayloadUnionPropertiesErrorData) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesErrorData) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesInfo 

type GlobalGetEventsResponsePayloadUnionPropertiesInfo struct {
	ID string `json:"id"`
	// This field is from variant [Pty].
	Args []string `json:"args"`
	// This field is from variant [Pty].
	Command string `json:"command"`
	// This field is from variant [Pty].
	Cwd string `json:"cwd"`
	// This field is from variant [Pty].
	Pid int64 `json:"pid"`
	// This field is from variant [Pty].
	Status PtyStatus `json:"status"`
	Title  string    `json:"title"`
	Agent  string    `json:"agent"`
	// This field is a union of [MessageUserMessageModel], [SessionModel]
	Model     GlobalGetEventsResponsePayloadUnionPropertiesInfoModel `json:"model"`
	Role      string                                                 `json:"role"`
	SessionID string                                                 `json:"sessionID"`
	// This field is a union of [MessageUserMessageTime], [AssistantMessageTime],
	// [SessionTime]
	Time GlobalGetEventsResponsePayloadUnionPropertiesInfoTime `json:"time"`
	// This field is from variant [MessageUnion].
	Format OutputFormatUnion `json:"format"`
	// This field is a union of [MessageUserMessageSummary], [bool], [SessionSummary]
	Summary GlobalGetEventsResponsePayloadUnionPropertiesInfoSummary `json:"summary"`
	// This field is from variant [MessageUnion].
	System string `json:"system"`
	// This field is from variant [MessageUnion].
	Tools map[string]bool `json:"tools"`
	Cost  float64         `json:"cost"`
	// This field is from variant [MessageUnion].
	Mode string `json:"mode"`
	// This field is from variant [MessageUnion].
	ModelID  string `json:"modelID"`
	ParentID string `json:"parentID"`
	// This field is a union of [AssistantMessagePath], [string]
	Path GlobalGetEventsResponsePayloadUnionPropertiesInfoPath `json:"path"`
	// This field is from variant [MessageUnion].
	ProviderID string `json:"providerID"`
	// This field is a union of [AssistantMessageTokens], [SessionTokens]
	Tokens GlobalGetEventsResponsePayloadUnionPropertiesInfoTokens `json:"tokens"`
	// This field is from variant [MessageUnion].
	Error AssistantMessageErrorUnion `json:"error"`
	// This field is from variant [MessageUnion].
	Finish string `json:"finish"`
	// This field is from variant [MessageUnion].
	Structured any `json:"structured"`
	// This field is from variant [MessageUnion].
	Variant string `json:"variant"`
	// This field is from variant [Session].
	Directory string `json:"directory"`
	// This field is from variant [Session].
	ProjectID string `json:"projectID"`
	// This field is from variant [Session].
	Slug string `json:"slug"`
	// This field is from variant [Session].
	Version string `json:"version"`
	// This field is from variant [Session].
	Permission []PermissionRule `json:"permission"`
	// This field is from variant [Session].
	Revert SessionRevert `json:"revert"`
	// This field is from variant [Session].
	Share SessionShare `json:"share"`
	// This field is from variant [Session].
	WorkspaceID string `json:"workspaceID"`
	JSON        struct {
		ID          respjson.Field
		Args        respjson.Field
		Command     respjson.Field
		Cwd         respjson.Field
		Pid         respjson.Field
		Status      respjson.Field
		Title       respjson.Field
		Agent       respjson.Field
		Model       respjson.Field
		Role        respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		Format      respjson.Field
		Summary     respjson.Field
		System      respjson.Field
		Tools       respjson.Field
		Cost        respjson.Field
		Mode        respjson.Field
		ModelID     respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		ProviderID  respjson.Field
		Tokens      respjson.Field
		Error       respjson.Field
		Finish      respjson.Field
		Structured  respjson.Field
		Variant     respjson.Field
		Directory   respjson.Field
		ProjectID   respjson.Field
		Slug        respjson.Field
		Version     respjson.Field
		Permission  respjson.Field
		Revert      respjson.Field
		Share       respjson.Field
		WorkspaceID respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesInfo is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesInfo provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesInfo) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesInfo) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesInfoModel 

type GlobalGetEventsResponsePayloadUnionPropertiesInfoModel struct {
	// This field is from variant [MessageUserMessageModel].
	ModelID    string `json:"modelID"`
	ProviderID string `json:"providerID"`
	Variant    string `json:"variant"`
	// This field is from variant [SessionModel].
	ID   string `json:"id"`
	JSON struct {
		ModelID    respjson.Field
		ProviderID respjson.Field
		Variant    respjson.Field
		ID         respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesInfoModel is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesInfoModel provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesInfoModel) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesInfoModel) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesInfoPath 

type GlobalGetEventsResponsePayloadUnionPropertiesInfoPath struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field is from variant [AssistantMessagePath].
	Cwd string `json:"cwd"`
	// This field is from variant [AssistantMessagePath].
	Root string `json:"root"`
	JSON struct {
		OfString respjson.Field
		Cwd      respjson.Field
		Root     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesInfoPath is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesInfoPath provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfString]

func (*GlobalGetEventsResponsePayloadUnionPropertiesInfoPath) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesInfoPath) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesInfoSummary 

type GlobalGetEventsResponsePayloadUnionPropertiesInfoSummary struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool bool               `json:",inline"`
	Diffs  []SnapshotFileDiff `json:"diffs"`
	// This field is from variant [MessageUserMessageSummary].
	Body string `json:"body"`
	// This field is from variant [MessageUserMessageSummary].
	Title string `json:"title"`
	// This field is from variant [SessionSummary].
	Additions float64 `json:"additions"`
	// This field is from variant [SessionSummary].
	Deletions float64 `json:"deletions"`
	// This field is from variant [SessionSummary].
	Files float64 `json:"files"`
	JSON  struct {
		OfBool    respjson.Field
		Diffs     respjson.Field
		Body      respjson.Field
		Title     respjson.Field
		Additions respjson.Field
		Deletions respjson.Field
		Files     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesInfoSummary is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesInfoSummary provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfBool]

func (*GlobalGetEventsResponsePayloadUnionPropertiesInfoSummary) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesInfoSummary) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesInfoTime 

type GlobalGetEventsResponsePayloadUnionPropertiesInfoTime struct {
	Created int64 `json:"created"`
	// This field is from variant [AssistantMessageTime].
	Completed int64 `json:"completed"`
	// This field is from variant [SessionTime].
	Updated int64 `json:"updated"`
	// This field is from variant [SessionTime].
	Archived float64 `json:"archived"`
	// This field is from variant [SessionTime].
	Compacting int64 `json:"compacting"`
	JSON       struct {
		Created    respjson.Field
		Completed  respjson.Field
		Updated    respjson.Field
		Archived   respjson.Field
		Compacting respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesInfoTime is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesInfoTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesInfoTime) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesInfoTime) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesInfoTokens 

type GlobalGetEventsResponsePayloadUnionPropertiesInfoTokens struct {
	// This field is a union of [AssistantMessageTokensCache], [SessionTokensCache]
	Cache     GlobalGetEventsResponsePayloadUnionPropertiesInfoTokensCache `json:"cache"`
	Input     float64                                                      `json:"input"`
	Output    float64                                                      `json:"output"`
	Reasoning float64                                                      `json:"reasoning"`
	// This field is from variant [AssistantMessageTokens].
	Total float64 `json:"total"`
	JSON  struct {
		Cache     respjson.Field
		Input     respjson.Field
		Output    respjson.Field
		Reasoning respjson.Field
		Total     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesInfoTokens is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesInfoTokens provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesInfoTokens) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesInfoTokens) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesInfoTokensCache 

type GlobalGetEventsResponsePayloadUnionPropertiesInfoTokensCache struct {
	Read  float64 `json:"read"`
	Write float64 `json:"write"`
	JSON  struct {
		Read  respjson.Field
		Write respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesInfoTokensCache is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesInfoTokensCache provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesInfoTokensCache) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesInfoTokensCache) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesModel 

type GlobalGetEventsResponsePayloadUnionPropertiesModel struct {
	ID         string `json:"id"`
	ProviderID string `json:"providerID"`
	Variant    string `json:"variant"`
	// This field is from variant [ModelV2Info].
	APIID string `json:"apiID"`
	// This field is from variant [ModelV2Info].
	Capabilities ModelV2InfoCapabilities `json:"capabilities"`
	// This field is from variant [ModelV2Info].
	Cost []ModelV2InfoCost `json:"cost"`
	// This field is from variant [ModelV2Info].
	Enabled bool `json:"enabled"`
	// This field is from variant [ModelV2Info].
	Endpoint ModelV2InfoEndpointUnion `json:"endpoint"`
	// This field is from variant [ModelV2Info].
	Limit ModelV2InfoLimit `json:"limit"`
	// This field is from variant [ModelV2Info].
	Name string `json:"name"`
	// This field is from variant [ModelV2Info].
	Options ModelV2InfoOptions `json:"options"`
	// This field is from variant [ModelV2Info].
	Status ModelV2InfoStatus `json:"status"`
	// This field is from variant [ModelV2Info].
	Time ModelV2InfoTime `json:"time"`
	// This field is from variant [ModelV2Info].
	Variants []ModelV2InfoVariant `json:"variants"`
	// This field is from variant [ModelV2Info].
	Family string `json:"family"`
	JSON   struct {
		ID           respjson.Field
		ProviderID   respjson.Field
		Variant      respjson.Field
		APIID        respjson.Field
		Capabilities respjson.Field
		Cost         respjson.Field
		Enabled      respjson.Field
		Endpoint     respjson.Field
		Limit        respjson.Field
		Name         respjson.Field
		Options      respjson.Field
		Status       respjson.Field
		Time         respjson.Field
		Variants     respjson.Field
		Family       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesModel is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesModel provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesModel) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesModel) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesProvider 

type GlobalGetEventsResponsePayloadUnionPropertiesProvider struct {
	Executed bool `json:"executed"`
	Metadata any  `json:"metadata"`
	JSON     struct {
		Executed respjson.Field
		Metadata respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesProvider is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesProvider provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

func (*GlobalGetEventsResponsePayloadUnionPropertiesProvider) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesProvider) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesStatus 

type GlobalGetEventsResponsePayloadUnionPropertiesStatus struct {
	// This field will be present if the value is a [string] instead of an object.
	OfEventWorkspaceStatusPropertiesStatus string `json:",inline"`
	Type                                   string `json:"type"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Attempt int64 `json:"attempt"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Message string `json:"message"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Next int64 `json:"next"`
	// This field is from variant [EventSessionStatusPropertiesStatusUnion].
	Action EventSessionStatusPropertiesStatusObjectAction `json:"action"`
	JSON   struct {
		OfEventWorkspaceStatusPropertiesStatus respjson.Field
		Type                                   respjson.Field
		Attempt                                respjson.Field
		Message                                respjson.Field
		Next                                   respjson.Field
		Action                                 respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesStatus is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesStatus provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfEventWorkspaceStatusPropertiesStatus]

func (*GlobalGetEventsResponsePayloadUnionPropertiesStatus) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesStatus) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesTime 

type GlobalGetEventsResponsePayloadUnionPropertiesTime struct {
	// This field will be present if the value is a [int64] instead of an object.
	OfInt int64 `json:",inline"`
	// This field is from variant [ProjectTime].
	Created int64 `json:"created"`
	// This field is from variant [ProjectTime].
	Updated int64 `json:"updated"`
	// This field is from variant [ProjectTime].
	Initialized int64 `json:"initialized"`
	JSON        struct {
		OfInt       respjson.Field
		Created     respjson.Field
		Updated     respjson.Field
		Initialized respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesTime is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfInt]

func (*GlobalGetEventsResponsePayloadUnionPropertiesTime) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesTime) UnmarshalJSON(data []byte) error

type GlobalGetEventsResponsePayloadUnionPropertiesTool 

type GlobalGetEventsResponsePayloadUnionPropertiesTool struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString  string `json:",inline"`
	CallID    string `json:"callID"`
	MessageID string `json:"messageID"`
	JSON      struct {
		OfString  respjson.Field
		CallID    respjson.Field
		MessageID respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalGetEventsResponsePayloadUnionPropertiesTool is an implicit subunion of GlobalGetEventsResponsePayloadUnion. GlobalGetEventsResponsePayloadUnionPropertiesTool provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the GlobalGetEventsResponsePayloadUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfString]

func (*GlobalGetEventsResponsePayloadUnionPropertiesTool) UnmarshalJSON 

func (r *GlobalGetEventsResponsePayloadUnionPropertiesTool) UnmarshalJSON(data []byte) error

type GlobalGetHealthResponse 

type GlobalGetHealthResponse struct {
	// Any of true.
	Healthy bool   `json:"healthy" api:"required"`
	Version string `json:"version" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Healthy     respjson.Field
		Version     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Health information

func (GlobalGetHealthResponse) RawJSON 

func (r GlobalGetHealthResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalGetHealthResponse) UnmarshalJSON 

func (r *GlobalGetHealthResponse) UnmarshalJSON(data []byte) error

type GlobalService 

type GlobalService struct {

	// Global server routes.
	Config GlobalConfigService
	// contains filtered or unexported fields
}

Global server routes.

GlobalService contains methods and other services that help with interacting with the opencode-stainless 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 NewGlobalService method instead.

func NewGlobalService 

func NewGlobalService(opts ...option.RequestOption) (r GlobalService)

NewGlobalService 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 (*GlobalService) DisposeInstances 

func (r *GlobalService) DisposeInstances(ctx context.Context, opts ...option.RequestOption) (res *bool, err error)

Clean up and dispose all OpenCode instances, releasing all resources.

func (*GlobalService) GetEventsStreaming 

func (r *GlobalService) GetEventsStreaming(ctx context.Context, opts ...option.RequestOption) (stream *ssestream.Stream[GlobalGetEventsResponse])

Subscribe to global events from the OpenCode system using server-sent events.

func (*GlobalService) GetHealth 

func (r *GlobalService) GetHealth(ctx context.Context, opts ...option.RequestOption) (res *GlobalGetHealthResponse, err error)

Get health information about the OpenCode server.

func (*GlobalService) UpgradeOpencode 

func (r *GlobalService) UpgradeOpencode(ctx context.Context, body GlobalUpgradeOpencodeParams, opts ...option.RequestOption) (res *GlobalUpgradeOpencodeResponseUnion, err error)

Upgrade opencode to the specified version or latest if not specified.

type GlobalUpgradeOpencodeParams 

type GlobalUpgradeOpencodeParams struct {
	Target param.Opt[string] `json:"target,omitzero"`
	// contains filtered or unexported fields
}

func (GlobalUpgradeOpencodeParams) MarshalJSON 

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

func (*GlobalUpgradeOpencodeParams) UnmarshalJSON 

func (r *GlobalUpgradeOpencodeParams) UnmarshalJSON(data []byte) error

type GlobalUpgradeOpencodeResponseObject 

type GlobalUpgradeOpencodeResponseObject struct {
	// Any of true.
	Success bool   `json:"success" api:"required"`
	Version string `json:"version" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Success     respjson.Field
		Version     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalUpgradeOpencodeResponseObject) RawJSON 

func (r GlobalUpgradeOpencodeResponseObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalUpgradeOpencodeResponseObject) UnmarshalJSON 

func (r *GlobalUpgradeOpencodeResponseObject) UnmarshalJSON(data []byte) error

type GlobalUpgradeOpencodeResponseObject2 

type GlobalUpgradeOpencodeResponseObject2 struct {
	Error string `json:"error" api:"required"`
	// Any of false.
	Success bool `json:"success" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		Success     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (GlobalUpgradeOpencodeResponseObject2) RawJSON 

func (r GlobalUpgradeOpencodeResponseObject2) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalUpgradeOpencodeResponseObject2) UnmarshalJSON 

func (r *GlobalUpgradeOpencodeResponseObject2) UnmarshalJSON(data []byte) error

type GlobalUpgradeOpencodeResponseUnion 

type GlobalUpgradeOpencodeResponseUnion struct {
	Success bool `json:"success"`
	// This field is from variant [GlobalUpgradeOpencodeResponseObject].
	Version string `json:"version"`
	// This field is from variant [GlobalUpgradeOpencodeResponseObject2].
	Error string `json:"error"`
	JSON  struct {
		Success respjson.Field
		Version respjson.Field
		Error   respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

GlobalUpgradeOpencodeResponseUnion contains all possible properties and values from GlobalUpgradeOpencodeResponseObject, GlobalUpgradeOpencodeResponseObject2.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (GlobalUpgradeOpencodeResponseUnion) AsGlobalUpgradeOpencodeResponseObject 

func (u GlobalUpgradeOpencodeResponseUnion) AsGlobalUpgradeOpencodeResponseObject() (v GlobalUpgradeOpencodeResponseObject)

func (GlobalUpgradeOpencodeResponseUnion) AsGlobalUpgradeOpencodeResponseObject2 

func (u GlobalUpgradeOpencodeResponseUnion) AsGlobalUpgradeOpencodeResponseObject2() (v GlobalUpgradeOpencodeResponseObject2)

func (GlobalUpgradeOpencodeResponseUnion) RawJSON 

func (u GlobalUpgradeOpencodeResponseUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*GlobalUpgradeOpencodeResponseUnion) UnmarshalJSON 

func (r *GlobalUpgradeOpencodeResponseUnion) UnmarshalJSON(data []byte) error

type InstanceDisposeParams 

type InstanceDisposeParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (InstanceDisposeParams) URLQuery 

func (r InstanceDisposeParams) URLQuery() (v url.Values, err error)

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

type InstanceService 

type InstanceService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

InstanceService contains methods and other services that help with interacting with the opencode-stainless 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 NewInstanceService method instead.

func NewInstanceService 

func NewInstanceService(opts ...option.RequestOption) (r InstanceService)

NewInstanceService 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 (*InstanceService) Dispose 

func (r *InstanceService) Dispose(ctx context.Context, body InstanceDisposeParams, opts ...option.RequestOption) (res *bool, err error)

Clean up and dispose the current OpenCode instance, releasing all resources.

type LogService 

type LogService struct {
	// contains filtered or unexported fields
}

Control plane routes.

LogService contains methods and other services that help with interacting with the opencode-stainless 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 NewLogService method instead.

func NewLogService 

func NewLogService(opts ...option.RequestOption) (r LogService)

NewLogService 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 (*LogService) Write 

func (r *LogService) Write(ctx context.Context, params LogWriteParams, opts ...option.RequestOption) (res *bool, err error)

Write a log entry to the server logs with specified level and metadata.

type LogWriteParams 

type LogWriteParams struct {
	// Log level
	//
	// Any of "debug", "info", "error", "warn".
	Level LogWriteParamsLevel `json:"level,omitzero" api:"required"`
	// Log message
	Message string `json:"message" api:"required"`
	// Service name for the log entry
	Service   string            `json:"service" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Extra     map[string]any    `json:"extra,omitzero"`
	// contains filtered or unexported fields
}

func (LogWriteParams) MarshalJSON 

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

func (LogWriteParams) URLQuery 

func (r LogWriteParams) URLQuery() (v url.Values, err error)

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

func (*LogWriteParams) UnmarshalJSON 

func (r *LogWriteParams) UnmarshalJSON(data []byte) error

type LogWriteParamsLevel 

type LogWriteParamsLevel string

Log level 

const (
	LogWriteParamsLevelDebug LogWriteParamsLevel = "debug"
	LogWriteParamsLevelInfo  LogWriteParamsLevel = "info"
	LogWriteParamsLevelError LogWriteParamsLevel = "error"
	LogWriteParamsLevelWarn  LogWriteParamsLevel = "warn"
)

type LspGetStatusParams 

type LspGetStatusParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (LspGetStatusParams) URLQuery 

func (r LspGetStatusParams) URLQuery() (v url.Values, err error)

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

type LspGetStatusResponse 

type LspGetStatusResponse struct {
	ID   string `json:"id" api:"required"`
	Name string `json:"name" api:"required"`
	Root string `json:"root" api:"required"`
	// Any of "connected", "error".
	Status LspGetStatusResponseStatus `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Name        respjson.Field
		Root        respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (LspGetStatusResponse) RawJSON 

func (r LspGetStatusResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*LspGetStatusResponse) UnmarshalJSON 

func (r *LspGetStatusResponse) UnmarshalJSON(data []byte) error

type LspGetStatusResponseStatus 

type LspGetStatusResponseStatus string
const (
	LspGetStatusResponseStatusConnected LspGetStatusResponseStatus = "connected"
	LspGetStatusResponseStatusError     LspGetStatusResponseStatus = "error"
)

type LspService 

type LspService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

LspService contains methods and other services that help with interacting with the opencode-stainless 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 NewLspService method instead.

func NewLspService 

func NewLspService(opts ...option.RequestOption) (r LspService)

NewLspService 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 (*LspService) GetStatus 

func (r *LspService) GetStatus(ctx context.Context, query LspGetStatusParams, opts ...option.RequestOption) (res *[]LspGetStatusResponse, err error)

Get LSP server status

type McpAddServerParams 

type McpAddServerParams struct {
	Config    McpAddServerParamsConfigUnion `json:"config,omitzero" api:"required"`
	Name      string                        `json:"name" api:"required"`
	Directory param.Opt[string]             `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]             `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpAddServerParams) MarshalJSON 

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

func (McpAddServerParams) URLQuery 

func (r McpAddServerParams) URLQuery() (v url.Values, err error)

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

func (*McpAddServerParams) UnmarshalJSON 

func (r *McpAddServerParams) UnmarshalJSON(data []byte) error

type McpAddServerParamsConfigMcpLocalConfig 

type McpAddServerParamsConfigMcpLocalConfig struct {
	// Command and arguments to run the MCP server
	Command []string `json:"command,omitzero" api:"required"`
	// Type of MCP server connection
	//
	// Any of "local".
	Type        string            `json:"type,omitzero" api:"required"`
	Enabled     param.Opt[bool]   `json:"enabled,omitzero"`
	Timeout     param.Opt[int64]  `json:"timeout,omitzero"`
	Environment map[string]string `json:"environment,omitzero"`
	// contains filtered or unexported fields
}

The properties Command, Type are required.

func (McpAddServerParamsConfigMcpLocalConfig) MarshalJSON 

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

func (*McpAddServerParamsConfigMcpLocalConfig) UnmarshalJSON 

func (r *McpAddServerParamsConfigMcpLocalConfig) UnmarshalJSON(data []byte) error

type McpAddServerParamsConfigMcpRemoteConfig 

type McpAddServerParamsConfigMcpRemoteConfig struct {
	// Type of MCP server connection
	//
	// Any of "remote".
	Type string `json:"type,omitzero" api:"required"`
	// URL of the remote MCP server
	URL     string            `json:"url" api:"required"`
	Enabled param.Opt[bool]   `json:"enabled,omitzero"`
	Timeout param.Opt[int64]  `json:"timeout,omitzero"`
	Headers map[string]string `json:"headers,omitzero"`
	// OAuth authentication configuration for the MCP server. Set to false to disable
	// OAuth auto-detection.
	OAuth McpAddServerParamsConfigMcpRemoteConfigOAuthUnion `json:"oauth,omitzero"`
	// contains filtered or unexported fields
}

The properties Type, URL are required.

func (McpAddServerParamsConfigMcpRemoteConfig) MarshalJSON 

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

func (*McpAddServerParamsConfigMcpRemoteConfig) UnmarshalJSON 

func (r *McpAddServerParamsConfigMcpRemoteConfig) UnmarshalJSON(data []byte) error

type McpAddServerParamsConfigMcpRemoteConfigOAuthBoolean 

type McpAddServerParamsConfigMcpRemoteConfigOAuthBoolean bool
const (
	McpAddServerParamsConfigMcpRemoteConfigOAuthBooleanFalse McpAddServerParamsConfigMcpRemoteConfigOAuthBoolean = false
)

type McpAddServerParamsConfigMcpRemoteConfigOAuthMcpOAuthConfig 

type McpAddServerParamsConfigMcpRemoteConfigOAuthMcpOAuthConfig struct {
	ClientID     param.Opt[string] `json:"clientId,omitzero"`
	ClientSecret param.Opt[string] `json:"clientSecret,omitzero"`
	RedirectUri  param.Opt[string] `json:"redirectUri,omitzero"`
	Scope        param.Opt[string] `json:"scope,omitzero"`
	// contains filtered or unexported fields
}

func (McpAddServerParamsConfigMcpRemoteConfigOAuthMcpOAuthConfig) MarshalJSON 

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

func (*McpAddServerParamsConfigMcpRemoteConfigOAuthMcpOAuthConfig) UnmarshalJSON 

func (r *McpAddServerParamsConfigMcpRemoteConfigOAuthMcpOAuthConfig) UnmarshalJSON(data []byte) error

type McpAddServerParamsConfigMcpRemoteConfigOAuthUnion 

type McpAddServerParamsConfigMcpRemoteConfigOAuthUnion struct {
	OfMcpAddServersConfigMcpRemoteConfigOAuthMcpOAuthConfig *McpAddServerParamsConfigMcpRemoteConfigOAuthMcpOAuthConfig `json:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfMcpAddServersConfigMcpRemoteConfigOAuthBoolean)
	OfMcpAddServersConfigMcpRemoteConfigOAuthBoolean param.Opt[bool] `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (McpAddServerParamsConfigMcpRemoteConfigOAuthUnion) MarshalJSON 

func (u McpAddServerParamsConfigMcpRemoteConfigOAuthUnion) MarshalJSON() ([]byte, error)

func (*McpAddServerParamsConfigMcpRemoteConfigOAuthUnion) UnmarshalJSON 

func (u *McpAddServerParamsConfigMcpRemoteConfigOAuthUnion) UnmarshalJSON(data []byte) error

type McpAddServerParamsConfigUnion 

type McpAddServerParamsConfigUnion struct {
	OfMcpAddServersConfigMcpLocalConfig  *McpAddServerParamsConfigMcpLocalConfig  `json:",omitzero,inline"`
	OfMcpAddServersConfigMcpRemoteConfig *McpAddServerParamsConfigMcpRemoteConfig `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (McpAddServerParamsConfigUnion) MarshalJSON 

func (u McpAddServerParamsConfigUnion) MarshalJSON() ([]byte, error)

func (*McpAddServerParamsConfigUnion) UnmarshalJSON 

func (u *McpAddServerParamsConfigUnion) UnmarshalJSON(data []byte) error

type McpAddServerResponse 

type McpAddServerResponse map[string]McpStatusUnion

type McpAuthAuthenticateOAuthParams 

type McpAuthAuthenticateOAuthParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpAuthAuthenticateOAuthParams) URLQuery 

func (r McpAuthAuthenticateOAuthParams) URLQuery() (v url.Values, err error)

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

type McpAuthCompleteOAuthParams 

type McpAuthCompleteOAuthParams struct {
	Code      string            `json:"code" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpAuthCompleteOAuthParams) MarshalJSON 

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

func (McpAuthCompleteOAuthParams) URLQuery 

func (r McpAuthCompleteOAuthParams) URLQuery() (v url.Values, err error)

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

func (*McpAuthCompleteOAuthParams) UnmarshalJSON 

func (r *McpAuthCompleteOAuthParams) UnmarshalJSON(data []byte) error

type McpAuthRemoveOAuthParams 

type McpAuthRemoveOAuthParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpAuthRemoveOAuthParams) URLQuery 

func (r McpAuthRemoveOAuthParams) URLQuery() (v url.Values, err error)

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

type McpAuthRemoveOAuthResponse 

type McpAuthRemoveOAuthResponse struct {
	// Any of true.
	Success bool `json:"success" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Success     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

OAuth credentials removed

func (McpAuthRemoveOAuthResponse) RawJSON 

func (r McpAuthRemoveOAuthResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpAuthRemoveOAuthResponse) UnmarshalJSON 

func (r *McpAuthRemoveOAuthResponse) UnmarshalJSON(data []byte) error

type McpAuthService 

type McpAuthService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi MCP routes.

McpAuthService contains methods and other services that help with interacting with the opencode-stainless 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 NewMcpAuthService method instead.

func NewMcpAuthService 

func NewMcpAuthService(opts ...option.RequestOption) (r McpAuthService)

NewMcpAuthService 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 (*McpAuthService) AuthenticateOAuth 

func (r *McpAuthService) AuthenticateOAuth(ctx context.Context, name string, body McpAuthAuthenticateOAuthParams, opts ...option.RequestOption) (res *McpStatusUnion, err error)

Start OAuth flow and wait for callback (opens browser).

func (*McpAuthService) CompleteOAuth 

func (r *McpAuthService) CompleteOAuth(ctx context.Context, name string, params McpAuthCompleteOAuthParams, opts ...option.RequestOption) (res *McpStatusUnion, err error)

Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.

func (*McpAuthService) RemoveOAuth 

func (r *McpAuthService) RemoveOAuth(ctx context.Context, name string, body McpAuthRemoveOAuthParams, opts ...option.RequestOption) (res *McpAuthRemoveOAuthResponse, err error)

Remove OAuth credentials for an MCP server.

func (*McpAuthService) StartOAuth 

func (r *McpAuthService) StartOAuth(ctx context.Context, name string, body McpAuthStartOAuthParams, opts ...option.RequestOption) (res *McpAuthStartOAuthResponse, err error)

Start OAuth authentication flow for a Model Context Protocol (MCP) server.

type McpAuthStartOAuthParams 

type McpAuthStartOAuthParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpAuthStartOAuthParams) URLQuery 

func (r McpAuthStartOAuthParams) URLQuery() (v url.Values, err error)

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

type McpAuthStartOAuthResponse 

type McpAuthStartOAuthResponse struct {
	AuthorizationURL string `json:"authorizationUrl" api:"required"`
	OAuthState       string `json:"oauthState" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AuthorizationURL respjson.Field
		OAuthState       respjson.Field
		ExtraFields      map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

OAuth flow started

func (McpAuthStartOAuthResponse) RawJSON 

func (r McpAuthStartOAuthResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpAuthStartOAuthResponse) UnmarshalJSON 

func (r *McpAuthStartOAuthResponse) UnmarshalJSON(data []byte) error

type McpConnectServerParams 

type McpConnectServerParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpConnectServerParams) URLQuery 

func (r McpConnectServerParams) URLQuery() (v url.Values, err error)

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

type McpDisconnectServerParams 

type McpDisconnectServerParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpDisconnectServerParams) URLQuery 

func (r McpDisconnectServerParams) URLQuery() (v url.Values, err error)

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

type McpGetStatusParams 

type McpGetStatusParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (McpGetStatusParams) URLQuery 

func (r McpGetStatusParams) URLQuery() (v url.Values, err error)

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

type McpGetStatusResponse 

type McpGetStatusResponse map[string]McpStatusUnion

type McpService 

type McpService struct {

	// Experimental HttpApi MCP routes.
	Auth McpAuthService
	// contains filtered or unexported fields
}

Experimental HttpApi MCP routes.

McpService contains methods and other services that help with interacting with the opencode-stainless 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 NewMcpService method instead.

func NewMcpService 

func NewMcpService(opts ...option.RequestOption) (r McpService)

NewMcpService 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 (*McpService) AddServer 

func (r *McpService) AddServer(ctx context.Context, params McpAddServerParams, opts ...option.RequestOption) (res *McpAddServerResponse, err error)

Dynamically add a new Model Context Protocol (MCP) server to the system.

func (*McpService) ConnectServer 

func (r *McpService) ConnectServer(ctx context.Context, name string, body McpConnectServerParams, opts ...option.RequestOption) (res *bool, err error)

Connect an MCP server.

func (*McpService) DisconnectServer 

func (r *McpService) DisconnectServer(ctx context.Context, name string, body McpDisconnectServerParams, opts ...option.RequestOption) (res *bool, err error)

Disconnect an MCP server.

func (*McpService) GetStatus 

func (r *McpService) GetStatus(ctx context.Context, query McpGetStatusParams, opts ...option.RequestOption) (res *McpGetStatusResponse, err error)

Get the status of all Model Context Protocol (MCP) servers.

type McpStatusMcpStatusConnected 

type McpStatusMcpStatusConnected struct {
	// Any of "connected".
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (McpStatusMcpStatusConnected) RawJSON 

func (r McpStatusMcpStatusConnected) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpStatusMcpStatusConnected) UnmarshalJSON 

func (r *McpStatusMcpStatusConnected) UnmarshalJSON(data []byte) error

type McpStatusMcpStatusDisabled 

type McpStatusMcpStatusDisabled struct {
	// Any of "disabled".
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (McpStatusMcpStatusDisabled) RawJSON 

func (r McpStatusMcpStatusDisabled) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpStatusMcpStatusDisabled) UnmarshalJSON 

func (r *McpStatusMcpStatusDisabled) UnmarshalJSON(data []byte) error

type McpStatusMcpStatusFailed 

type McpStatusMcpStatusFailed struct {
	Error string `json:"error" api:"required"`
	// Any of "failed".
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (McpStatusMcpStatusFailed) RawJSON 

func (r McpStatusMcpStatusFailed) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpStatusMcpStatusFailed) UnmarshalJSON 

func (r *McpStatusMcpStatusFailed) UnmarshalJSON(data []byte) error

type McpStatusMcpStatusNeedsAuth 

type McpStatusMcpStatusNeedsAuth struct {
	// Any of "needs_auth".
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (McpStatusMcpStatusNeedsAuth) RawJSON 

func (r McpStatusMcpStatusNeedsAuth) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpStatusMcpStatusNeedsAuth) UnmarshalJSON 

func (r *McpStatusMcpStatusNeedsAuth) UnmarshalJSON(data []byte) error

type McpStatusMcpStatusNeedsClientRegistration 

type McpStatusMcpStatusNeedsClientRegistration struct {
	Error string `json:"error" api:"required"`
	// Any of "needs_client_registration".
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (McpStatusMcpStatusNeedsClientRegistration) RawJSON 

func (r McpStatusMcpStatusNeedsClientRegistration) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpStatusMcpStatusNeedsClientRegistration) UnmarshalJSON 

func (r *McpStatusMcpStatusNeedsClientRegistration) UnmarshalJSON(data []byte) error

type McpStatusUnion 

type McpStatusUnion struct {
	Status string `json:"status"`
	Error  string `json:"error"`
	JSON   struct {
		Status respjson.Field
		Error  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

McpStatusUnion contains all possible properties and values from McpStatusMcpStatusConnected, McpStatusMcpStatusDisabled, McpStatusMcpStatusFailed, McpStatusMcpStatusNeedsAuth, McpStatusMcpStatusNeedsClientRegistration.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (McpStatusUnion) AsMcpStatusMcpStatusConnected 

func (u McpStatusUnion) AsMcpStatusMcpStatusConnected() (v McpStatusMcpStatusConnected)

func (McpStatusUnion) AsMcpStatusMcpStatusDisabled 

func (u McpStatusUnion) AsMcpStatusMcpStatusDisabled() (v McpStatusMcpStatusDisabled)

func (McpStatusUnion) AsMcpStatusMcpStatusFailed 

func (u McpStatusUnion) AsMcpStatusMcpStatusFailed() (v McpStatusMcpStatusFailed)

func (McpStatusUnion) AsMcpStatusMcpStatusNeedsAuth 

func (u McpStatusUnion) AsMcpStatusMcpStatusNeedsAuth() (v McpStatusMcpStatusNeedsAuth)

func (McpStatusUnion) AsMcpStatusMcpStatusNeedsClientRegistration 

func (u McpStatusUnion) AsMcpStatusMcpStatusNeedsClientRegistration() (v McpStatusMcpStatusNeedsClientRegistration)

func (McpStatusUnion) RawJSON 

func (u McpStatusUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*McpStatusUnion) UnmarshalJSON 

func (r *McpStatusUnion) UnmarshalJSON(data []byte) error

type MessageAbortedError 

type MessageAbortedError struct {
	Data MessageAbortedErrorData `json:"data" api:"required"`
	// Any of "MessageAbortedError".
	Name MessageAbortedErrorName `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MessageAbortedError) RawJSON 

func (r MessageAbortedError) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageAbortedError) UnmarshalJSON 

func (r *MessageAbortedError) UnmarshalJSON(data []byte) error

type MessageAbortedErrorData 

type MessageAbortedErrorData struct {
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MessageAbortedErrorData) RawJSON 

func (r MessageAbortedErrorData) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageAbortedErrorData) UnmarshalJSON 

func (r *MessageAbortedErrorData) UnmarshalJSON(data []byte) error

type MessageAbortedErrorName 

type MessageAbortedErrorName string
const (
	MessageAbortedErrorNameMessageAbortedError MessageAbortedErrorName = "MessageAbortedError"
)

type MessageOutputLengthError 

type MessageOutputLengthError struct {
	Data map[string]any `json:"data" api:"required"`
	// Any of "MessageOutputLengthError".
	Name MessageOutputLengthErrorName `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MessageOutputLengthError) RawJSON 

func (r MessageOutputLengthError) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageOutputLengthError) UnmarshalJSON 

func (r *MessageOutputLengthError) UnmarshalJSON(data []byte) error

type MessageOutputLengthErrorName 

type MessageOutputLengthErrorName string
const (
	MessageOutputLengthErrorNameMessageOutputLengthError MessageOutputLengthErrorName = "MessageOutputLengthError"
)

type MessageUnion 

type MessageUnion struct {
	ID    string `json:"id"`
	Agent string `json:"agent"`
	// This field is from variant [MessageUserMessage].
	Model     MessageUserMessageModel `json:"model"`
	Role      string                  `json:"role"`
	SessionID string                  `json:"sessionID"`
	// This field is a union of [MessageUserMessageTime], [AssistantMessageTime]
	Time MessageUnionTime `json:"time"`
	// This field is from variant [MessageUserMessage].
	Format OutputFormatUnion `json:"format"`
	// This field is a union of [MessageUserMessageSummary], [bool]
	Summary MessageUnionSummary `json:"summary"`
	// This field is from variant [MessageUserMessage].
	System string `json:"system"`
	// This field is from variant [MessageUserMessage].
	Tools map[string]bool `json:"tools"`
	// This field is from variant [AssistantMessage].
	Cost float64 `json:"cost"`
	// This field is from variant [AssistantMessage].
	Mode string `json:"mode"`
	// This field is from variant [AssistantMessage].
	ModelID string `json:"modelID"`
	// This field is from variant [AssistantMessage].
	ParentID string `json:"parentID"`
	// This field is from variant [AssistantMessage].
	Path AssistantMessagePath `json:"path"`
	// This field is from variant [AssistantMessage].
	ProviderID string `json:"providerID"`
	// This field is from variant [AssistantMessage].
	Tokens AssistantMessageTokens `json:"tokens"`
	// This field is from variant [AssistantMessage].
	Error AssistantMessageErrorUnion `json:"error"`
	// This field is from variant [AssistantMessage].
	Finish string `json:"finish"`
	// This field is from variant [AssistantMessage].
	Structured any `json:"structured"`
	// This field is from variant [AssistantMessage].
	Variant string `json:"variant"`
	JSON    struct {
		ID         respjson.Field
		Agent      respjson.Field
		Model      respjson.Field
		Role       respjson.Field
		SessionID  respjson.Field
		Time       respjson.Field
		Format     respjson.Field
		Summary    respjson.Field
		System     respjson.Field
		Tools      respjson.Field
		Cost       respjson.Field
		Mode       respjson.Field
		ModelID    respjson.Field
		ParentID   respjson.Field
		Path       respjson.Field
		ProviderID respjson.Field
		Tokens     respjson.Field
		Error      respjson.Field
		Finish     respjson.Field
		Structured respjson.Field
		Variant    respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

MessageUnion contains all possible properties and values from MessageUserMessage, AssistantMessage.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (MessageUnion) AsAssistantMessage 

func (u MessageUnion) AsAssistantMessage() (v AssistantMessage)

func (MessageUnion) AsMessageUserMessage 

func (u MessageUnion) AsMessageUserMessage() (v MessageUserMessage)

func (MessageUnion) RawJSON 

func (u MessageUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageUnion) UnmarshalJSON 

func (r *MessageUnion) UnmarshalJSON(data []byte) error

type MessageUnionSummary 

type MessageUnionSummary struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool bool `json:",inline"`
	// This field is from variant [MessageUserMessageSummary].
	Diffs []SnapshotFileDiff `json:"diffs"`
	// This field is from variant [MessageUserMessageSummary].
	Body string `json:"body"`
	// This field is from variant [MessageUserMessageSummary].
	Title string `json:"title"`
	JSON  struct {
		OfBool respjson.Field
		Diffs  respjson.Field
		Body   respjson.Field
		Title  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

MessageUnionSummary is an implicit subunion of MessageUnion. MessageUnionSummary provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the MessageUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfBool]

func (*MessageUnionSummary) UnmarshalJSON 

func (r *MessageUnionSummary) UnmarshalJSON(data []byte) error

type MessageUnionTime 

type MessageUnionTime struct {
	Created int64 `json:"created"`
	// This field is from variant [AssistantMessageTime].
	Completed int64 `json:"completed"`
	JSON      struct {
		Created   respjson.Field
		Completed respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

MessageUnionTime is an implicit subunion of MessageUnion. MessageUnionTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the MessageUnion.

func (*MessageUnionTime) UnmarshalJSON 

func (r *MessageUnionTime) UnmarshalJSON(data []byte) error

type MessageUserMessage 

type MessageUserMessage struct {
	ID    string                  `json:"id" api:"required"`
	Agent string                  `json:"agent" api:"required"`
	Model MessageUserMessageModel `json:"model" api:"required"`
	// Any of "user".
	Role      string                    `json:"role" api:"required"`
	SessionID string                    `json:"sessionID" api:"required"`
	Time      MessageUserMessageTime    `json:"time" api:"required"`
	Format    OutputFormatUnion         `json:"format"`
	Summary   MessageUserMessageSummary `json:"summary"`
	System    string                    `json:"system"`
	Tools     map[string]bool           `json:"tools"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Agent       respjson.Field
		Model       respjson.Field
		Role        respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		Format      respjson.Field
		Summary     respjson.Field
		System      respjson.Field
		Tools       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MessageUserMessage) RawJSON 

func (r MessageUserMessage) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageUserMessage) UnmarshalJSON 

func (r *MessageUserMessage) UnmarshalJSON(data []byte) error

type MessageUserMessageModel 

type MessageUserMessageModel struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ModelID     respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MessageUserMessageModel) RawJSON 

func (r MessageUserMessageModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageUserMessageModel) UnmarshalJSON 

func (r *MessageUserMessageModel) UnmarshalJSON(data []byte) error

type MessageUserMessageSummary 

type MessageUserMessageSummary struct {
	Diffs []SnapshotFileDiff `json:"diffs" api:"required"`
	Body  string             `json:"body"`
	Title string             `json:"title"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Diffs       respjson.Field
		Body        respjson.Field
		Title       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MessageUserMessageSummary) RawJSON 

func (r MessageUserMessageSummary) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageUserMessageSummary) UnmarshalJSON 

func (r *MessageUserMessageSummary) UnmarshalJSON(data []byte) error

type MessageUserMessageTime 

type MessageUserMessageTime struct {
	Created int64 `json:"created" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MessageUserMessageTime) RawJSON 

func (r MessageUserMessageTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*MessageUserMessageTime) UnmarshalJSON 

func (r *MessageUserMessageTime) UnmarshalJSON(data []byte) error

type ModelV2Info 

type ModelV2Info struct {
	ID           string                   `json:"id" api:"required"`
	APIID        string                   `json:"apiID" api:"required"`
	Capabilities ModelV2InfoCapabilities  `json:"capabilities" api:"required"`
	Cost         []ModelV2InfoCost        `json:"cost" api:"required"`
	Enabled      bool                     `json:"enabled" api:"required"`
	Endpoint     ModelV2InfoEndpointUnion `json:"endpoint" api:"required"`
	Limit        ModelV2InfoLimit         `json:"limit" api:"required"`
	Name         string                   `json:"name" api:"required"`
	Options      ModelV2InfoOptions       `json:"options" api:"required"`
	ProviderID   string                   `json:"providerID" api:"required"`
	// Any of "alpha", "beta", "deprecated", "active".
	Status   ModelV2InfoStatus    `json:"status" api:"required"`
	Time     ModelV2InfoTime      `json:"time" api:"required"`
	Variants []ModelV2InfoVariant `json:"variants" api:"required"`
	Family   string               `json:"family"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID           respjson.Field
		APIID        respjson.Field
		Capabilities respjson.Field
		Cost         respjson.Field
		Enabled      respjson.Field
		Endpoint     respjson.Field
		Limit        respjson.Field
		Name         respjson.Field
		Options      respjson.Field
		ProviderID   respjson.Field
		Status       respjson.Field
		Time         respjson.Field
		Variants     respjson.Field
		Family       respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2Info) RawJSON 

func (r ModelV2Info) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2Info) UnmarshalJSON 

func (r *ModelV2Info) UnmarshalJSON(data []byte) error

type ModelV2InfoCapabilities 

type ModelV2InfoCapabilities struct {
	Input  []string `json:"input" api:"required"`
	Output []string `json:"output" api:"required"`
	Tools  bool     `json:"tools" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input       respjson.Field
		Output      respjson.Field
		Tools       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoCapabilities) RawJSON 

func (r ModelV2InfoCapabilities) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoCapabilities) UnmarshalJSON 

func (r *ModelV2InfoCapabilities) UnmarshalJSON(data []byte) error

type ModelV2InfoCost 

type ModelV2InfoCost struct {
	Cache  ModelV2InfoCostCache `json:"cache" api:"required"`
	Input  float64              `json:"input" api:"required"`
	Output float64              `json:"output" api:"required"`
	Tier   ModelV2InfoCostTier  `json:"tier"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Tier        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoCost) RawJSON 

func (r ModelV2InfoCost) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoCost) UnmarshalJSON 

func (r *ModelV2InfoCost) UnmarshalJSON(data []byte) error

type ModelV2InfoCostCache 

type ModelV2InfoCostCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoCostCache) RawJSON 

func (r ModelV2InfoCostCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoCostCache) UnmarshalJSON 

func (r *ModelV2InfoCostCache) UnmarshalJSON(data []byte) error

type ModelV2InfoCostTier 

type ModelV2InfoCostTier struct {
	Size int64 `json:"size" api:"required"`
	// Any of "context".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Size        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoCostTier) RawJSON 

func (r ModelV2InfoCostTier) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoCostTier) UnmarshalJSON 

func (r *ModelV2InfoCostTier) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointObject 

type ModelV2InfoEndpointObject struct {
	// Any of "openai/responses".
	Type      string `json:"type" api:"required"`
	URL       string `json:"url" api:"required"`
	Websocket bool   `json:"websocket"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Websocket   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoEndpointObject) RawJSON 

func (r ModelV2InfoEndpointObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointObject) UnmarshalJSON 

func (r *ModelV2InfoEndpointObject) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointObject2 

type ModelV2InfoEndpointObject2 struct {
	// Any of "openai/completions".
	Type      string                                   `json:"type" api:"required"`
	URL       string                                   `json:"url" api:"required"`
	Reasoning ModelV2InfoEndpointObject2ReasoningUnion `json:"reasoning"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoEndpointObject2) RawJSON 

func (r ModelV2InfoEndpointObject2) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointObject2) UnmarshalJSON 

func (r *ModelV2InfoEndpointObject2) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointObject2ReasoningType 

type ModelV2InfoEndpointObject2ReasoningType struct {
	// Any of "reasoning_content".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoEndpointObject2ReasoningType) RawJSON 

func (r ModelV2InfoEndpointObject2ReasoningType) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointObject2ReasoningType) UnmarshalJSON 

func (r *ModelV2InfoEndpointObject2ReasoningType) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointObject2ReasoningType2 

type ModelV2InfoEndpointObject2ReasoningType2 struct {
	// Any of "reasoning_details".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoEndpointObject2ReasoningType2) RawJSON 

func (r ModelV2InfoEndpointObject2ReasoningType2) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointObject2ReasoningType2) UnmarshalJSON 

func (r *ModelV2InfoEndpointObject2ReasoningType2) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointObject2ReasoningUnion 

type ModelV2InfoEndpointObject2ReasoningUnion struct {
	Type string `json:"type"`
	JSON struct {
		Type respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ModelV2InfoEndpointObject2ReasoningUnion contains all possible properties and values from ModelV2InfoEndpointObject2ReasoningType, ModelV2InfoEndpointObject2ReasoningType2.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (ModelV2InfoEndpointObject2ReasoningUnion) AsModelV2InfoEndpointObject2ReasoningType 

func (u ModelV2InfoEndpointObject2ReasoningUnion) AsModelV2InfoEndpointObject2ReasoningType() (v ModelV2InfoEndpointObject2ReasoningType)

func (ModelV2InfoEndpointObject2ReasoningUnion) AsModelV2InfoEndpointObject2ReasoningType2 

func (u ModelV2InfoEndpointObject2ReasoningUnion) AsModelV2InfoEndpointObject2ReasoningType2() (v ModelV2InfoEndpointObject2ReasoningType2)

func (ModelV2InfoEndpointObject2ReasoningUnion) RawJSON 

func (u ModelV2InfoEndpointObject2ReasoningUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointObject2ReasoningUnion) UnmarshalJSON 

func (r *ModelV2InfoEndpointObject2ReasoningUnion) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointObject3 

type ModelV2InfoEndpointObject3 struct {
	// Any of "anthropic/messages".
	Type string `json:"type" api:"required"`
	URL  string `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoEndpointObject3) RawJSON 

func (r ModelV2InfoEndpointObject3) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointObject3) UnmarshalJSON 

func (r *ModelV2InfoEndpointObject3) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointObject4 

type ModelV2InfoEndpointObject4 struct {
	Package string `json:"package" api:"required"`
	// Any of "aisdk".
	Type string `json:"type" api:"required"`
	URL  string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Package     respjson.Field
		Type        respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoEndpointObject4) RawJSON 

func (r ModelV2InfoEndpointObject4) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointObject4) UnmarshalJSON 

func (r *ModelV2InfoEndpointObject4) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointType 

type ModelV2InfoEndpointType struct {
	// Any of "unknown".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoEndpointType) RawJSON 

func (r ModelV2InfoEndpointType) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointType) UnmarshalJSON 

func (r *ModelV2InfoEndpointType) UnmarshalJSON(data []byte) error

type ModelV2InfoEndpointUnion 

type ModelV2InfoEndpointUnion struct {
	Type string `json:"type"`
	URL  string `json:"url"`
	// This field is from variant [ModelV2InfoEndpointObject].
	Websocket bool `json:"websocket"`
	// This field is from variant [ModelV2InfoEndpointObject2].
	Reasoning ModelV2InfoEndpointObject2ReasoningUnion `json:"reasoning"`
	// This field is from variant [ModelV2InfoEndpointObject4].
	Package string `json:"package"`
	JSON    struct {
		Type      respjson.Field
		URL       respjson.Field
		Websocket respjson.Field
		Reasoning respjson.Field
		Package   respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ModelV2InfoEndpointUnion contains all possible properties and values from ModelV2InfoEndpointType, ModelV2InfoEndpointObject, ModelV2InfoEndpointObject2, ModelV2InfoEndpointObject3, ModelV2InfoEndpointObject4.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject 

func (u ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject() (v ModelV2InfoEndpointObject)

func (ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject2 

func (u ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject2() (v ModelV2InfoEndpointObject2)

func (ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject3 

func (u ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject3() (v ModelV2InfoEndpointObject3)

func (ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject4 

func (u ModelV2InfoEndpointUnion) AsModelV2InfoEndpointObject4() (v ModelV2InfoEndpointObject4)

func (ModelV2InfoEndpointUnion) AsModelV2InfoEndpointType 

func (u ModelV2InfoEndpointUnion) AsModelV2InfoEndpointType() (v ModelV2InfoEndpointType)

func (ModelV2InfoEndpointUnion) RawJSON 

func (u ModelV2InfoEndpointUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoEndpointUnion) UnmarshalJSON 

func (r *ModelV2InfoEndpointUnion) UnmarshalJSON(data []byte) error

type ModelV2InfoLimit 

type ModelV2InfoLimit struct {
	Context int64 `json:"context" api:"required"`
	Output  int64 `json:"output" api:"required"`
	Input   int64 `json:"input"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Context     respjson.Field
		Output      respjson.Field
		Input       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoLimit) RawJSON 

func (r ModelV2InfoLimit) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoLimit) UnmarshalJSON 

func (r *ModelV2InfoLimit) UnmarshalJSON(data []byte) error

type ModelV2InfoOptions 

type ModelV2InfoOptions struct {
	Aisdk   ModelV2InfoOptionsAisdk `json:"aisdk" api:"required"`
	Body    map[string]any          `json:"body" api:"required"`
	Headers map[string]string       `json:"headers" api:"required"`
	Variant string                  `json:"variant"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Aisdk       respjson.Field
		Body        respjson.Field
		Headers     respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoOptions) RawJSON 

func (r ModelV2InfoOptions) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoOptions) UnmarshalJSON 

func (r *ModelV2InfoOptions) UnmarshalJSON(data []byte) error

type ModelV2InfoOptionsAisdk 

type ModelV2InfoOptionsAisdk struct {
	Provider map[string]any `json:"provider" api:"required"`
	Request  map[string]any `json:"request" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Provider    respjson.Field
		Request     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoOptionsAisdk) RawJSON 

func (r ModelV2InfoOptionsAisdk) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoOptionsAisdk) UnmarshalJSON 

func (r *ModelV2InfoOptionsAisdk) UnmarshalJSON(data []byte) error

type ModelV2InfoStatus 

type ModelV2InfoStatus string
const (
	ModelV2InfoStatusAlpha      ModelV2InfoStatus = "alpha"
	ModelV2InfoStatusBeta       ModelV2InfoStatus = "beta"
	ModelV2InfoStatusDeprecated ModelV2InfoStatus = "deprecated"
	ModelV2InfoStatusActive     ModelV2InfoStatus = "active"
)

type ModelV2InfoTime 

type ModelV2InfoTime struct {
	Released ModelV2InfoTimeReleasedUnion `json:"released" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Released    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoTime) RawJSON 

func (r ModelV2InfoTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoTime) UnmarshalJSON 

func (r *ModelV2InfoTime) UnmarshalJSON(data []byte) error

type ModelV2InfoTimeReleasedString 

type ModelV2InfoTimeReleasedString string
const (
	ModelV2InfoTimeReleasedStringNaN           ModelV2InfoTimeReleasedString = "NaN"
	ModelV2InfoTimeReleasedStringInfinity      ModelV2InfoTimeReleasedString = "Infinity"
	ModelV2InfoTimeReleasedStringMinusInfinity ModelV2InfoTimeReleasedString = "-Infinity"
)

type ModelV2InfoTimeReleasedUnion 

type ModelV2InfoTimeReleasedUnion struct {
	// This field will be present if the value is a [float64] instead of an object.
	OfFloat float64 `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfModelV2InfoTimeReleasedString string `json:",inline"`
	JSON                            struct {
		OfFloat                         respjson.Field
		OfModelV2InfoTimeReleasedString respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ModelV2InfoTimeReleasedUnion contains all possible properties and values from [float64], [string].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfFloat OfModelV2InfoTimeReleasedString]

func (ModelV2InfoTimeReleasedUnion) AsFloat 

func (u ModelV2InfoTimeReleasedUnion) AsFloat() (v float64)

func (ModelV2InfoTimeReleasedUnion) AsModelV2InfoTimeReleasedString 

func (u ModelV2InfoTimeReleasedUnion) AsModelV2InfoTimeReleasedString() (v string)

func (ModelV2InfoTimeReleasedUnion) RawJSON 

func (u ModelV2InfoTimeReleasedUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoTimeReleasedUnion) UnmarshalJSON 

func (r *ModelV2InfoTimeReleasedUnion) UnmarshalJSON(data []byte) error

type ModelV2InfoVariant 

type ModelV2InfoVariant struct {
	ID      string                  `json:"id" api:"required"`
	Aisdk   ModelV2InfoVariantAisdk `json:"aisdk" api:"required"`
	Body    map[string]any          `json:"body" api:"required"`
	Headers map[string]string       `json:"headers" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Aisdk       respjson.Field
		Body        respjson.Field
		Headers     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoVariant) RawJSON 

func (r ModelV2InfoVariant) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoVariant) UnmarshalJSON 

func (r *ModelV2InfoVariant) UnmarshalJSON(data []byte) error

type ModelV2InfoVariantAisdk 

type ModelV2InfoVariantAisdk struct {
	Provider map[string]any `json:"provider" api:"required"`
	Request  map[string]any `json:"request" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Provider    respjson.Field
		Request     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ModelV2InfoVariantAisdk) RawJSON 

func (r ModelV2InfoVariantAisdk) RawJSON() string

Returns the unmodified JSON received from the API

func (*ModelV2InfoVariantAisdk) UnmarshalJSON 

func (r *ModelV2InfoVariantAisdk) UnmarshalJSON(data []byte) error

type OutputFormatOutputFormatJsonSchema 

type OutputFormatOutputFormatJsonSchema struct {
	Schema map[string]any `json:"schema" api:"required"`
	// Any of "json_schema".
	Type       string `json:"type" api:"required"`
	RetryCount int64  `json:"retryCount"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Schema      respjson.Field
		Type        respjson.Field
		RetryCount  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (OutputFormatOutputFormatJsonSchema) RawJSON 

func (r OutputFormatOutputFormatJsonSchema) RawJSON() string

Returns the unmodified JSON received from the API

func (*OutputFormatOutputFormatJsonSchema) UnmarshalJSON 

func (r *OutputFormatOutputFormatJsonSchema) UnmarshalJSON(data []byte) error

type OutputFormatOutputFormatJsonSchemaParam 

type OutputFormatOutputFormatJsonSchemaParam struct {
	Schema map[string]any `json:"schema,omitzero" api:"required"`
	// Any of "json_schema".
	Type       string           `json:"type,omitzero" api:"required"`
	RetryCount param.Opt[int64] `json:"retryCount,omitzero"`
	// contains filtered or unexported fields
}

The properties Schema, Type are required.

func (OutputFormatOutputFormatJsonSchemaParam) MarshalJSON 

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

func (*OutputFormatOutputFormatJsonSchemaParam) UnmarshalJSON 

func (r *OutputFormatOutputFormatJsonSchemaParam) UnmarshalJSON(data []byte) error

type OutputFormatOutputFormatText 

type OutputFormatOutputFormatText struct {
	// Any of "text".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (OutputFormatOutputFormatText) RawJSON 

func (r OutputFormatOutputFormatText) RawJSON() string

Returns the unmodified JSON received from the API

func (*OutputFormatOutputFormatText) UnmarshalJSON 

func (r *OutputFormatOutputFormatText) UnmarshalJSON(data []byte) error

type OutputFormatOutputFormatTextParam 

type OutputFormatOutputFormatTextParam struct {
	// Any of "text".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The property Type is required.

func (OutputFormatOutputFormatTextParam) MarshalJSON 

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

func (*OutputFormatOutputFormatTextParam) UnmarshalJSON 

func (r *OutputFormatOutputFormatTextParam) UnmarshalJSON(data []byte) error

type OutputFormatUnion 

type OutputFormatUnion struct {
	Type string `json:"type"`
	// This field is from variant [OutputFormatOutputFormatJsonSchema].
	Schema map[string]any `json:"schema"`
	// This field is from variant [OutputFormatOutputFormatJsonSchema].
	RetryCount int64 `json:"retryCount"`
	JSON       struct {
		Type       respjson.Field
		Schema     respjson.Field
		RetryCount respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

OutputFormatUnion contains all possible properties and values from OutputFormatOutputFormatText, OutputFormatOutputFormatJsonSchema.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (OutputFormatUnion) AsOutputFormatOutputFormatJsonSchema 

func (u OutputFormatUnion) AsOutputFormatOutputFormatJsonSchema() (v OutputFormatOutputFormatJsonSchema)

func (OutputFormatUnion) AsOutputFormatOutputFormatText 

func (u OutputFormatUnion) AsOutputFormatOutputFormatText() (v OutputFormatOutputFormatText)

func (OutputFormatUnion) RawJSON 

func (u OutputFormatUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (OutputFormatUnion) ToParam 

func (r OutputFormatUnion) ToParam() OutputFormatUnionParam

ToParam converts this OutputFormatUnion to a OutputFormatUnionParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with OutputFormatUnionParam.Overrides()

func (*OutputFormatUnion) UnmarshalJSON 

func (r *OutputFormatUnion) UnmarshalJSON(data []byte) error

type OutputFormatUnionParam 

type OutputFormatUnionParam struct {
	OfOutputFormatOutputFormatText       *OutputFormatOutputFormatTextParam       `json:",omitzero,inline"`
	OfOutputFormatOutputFormatJsonSchema *OutputFormatOutputFormatJsonSchemaParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func OutputFormatParamOfOutputFormatOutputFormatJsonSchema 

func OutputFormatParamOfOutputFormatOutputFormatJsonSchema(schema map[string]any, type_ string) OutputFormatUnionParam

func OutputFormatParamOfOutputFormatOutputFormatText 

func OutputFormatParamOfOutputFormatOutputFormatText(type_ string) OutputFormatUnionParam

func (OutputFormatUnionParam) MarshalJSON 

func (u OutputFormatUnionParam) MarshalJSON() ([]byte, error)

func (*OutputFormatUnionParam) UnmarshalJSON 

func (u *OutputFormatUnionParam) UnmarshalJSON(data []byte) error

type PartAgentPart 

type PartAgentPart struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	Name      string `json:"name" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "agent".
	Type   string              `json:"type" api:"required"`
	Source PartAgentPartSource `json:"source"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		MessageID   respjson.Field
		Name        respjson.Field
		SessionID   respjson.Field
		Type        respjson.Field
		Source      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartAgentPart) RawJSON 

func (r PartAgentPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartAgentPart) UnmarshalJSON 

func (r *PartAgentPart) UnmarshalJSON(data []byte) error

type PartAgentPartParam 

type PartAgentPartParam struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	Name      string `json:"name" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "agent".
	Type   string                   `json:"type,omitzero" api:"required"`
	Source PartAgentPartSourceParam `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, MessageID, Name, SessionID, Type are required.

func (PartAgentPartParam) MarshalJSON 

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

func (*PartAgentPartParam) UnmarshalJSON 

func (r *PartAgentPartParam) UnmarshalJSON(data []byte) error

type PartAgentPartSource 

type PartAgentPartSource struct {
	End   int64  `json:"end" api:"required"`
	Start int64  `json:"start" api:"required"`
	Value string `json:"value" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Start       respjson.Field
		Value       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartAgentPartSource) RawJSON 

func (r PartAgentPartSource) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartAgentPartSource) UnmarshalJSON 

func (r *PartAgentPartSource) UnmarshalJSON(data []byte) error

type PartAgentPartSourceParam 

type PartAgentPartSourceParam struct {
	End   int64  `json:"end" api:"required"`
	Start int64  `json:"start" api:"required"`
	Value string `json:"value" api:"required"`
	// contains filtered or unexported fields
}

The properties End, Start, Value are required.

func (PartAgentPartSourceParam) MarshalJSON 

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

func (*PartAgentPartSourceParam) UnmarshalJSON 

func (r *PartAgentPartSourceParam) UnmarshalJSON(data []byte) error

type PartCompactionPart 

type PartCompactionPart struct {
	ID        string `json:"id" api:"required"`
	Auto      bool   `json:"auto" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "compaction".
	Type        string `json:"type" api:"required"`
	Overflow    bool   `json:"overflow"`
	TailStartID string `json:"tail_start_id"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Auto        respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Type        respjson.Field
		Overflow    respjson.Field
		TailStartID respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartCompactionPart) RawJSON 

func (r PartCompactionPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartCompactionPart) UnmarshalJSON 

func (r *PartCompactionPart) UnmarshalJSON(data []byte) error

type PartCompactionPartParam 

type PartCompactionPartParam struct {
	ID        string `json:"id" api:"required"`
	Auto      bool   `json:"auto" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "compaction".
	Type        string            `json:"type,omitzero" api:"required"`
	Overflow    param.Opt[bool]   `json:"overflow,omitzero"`
	TailStartID param.Opt[string] `json:"tail_start_id,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, Auto, MessageID, SessionID, Type are required.

func (PartCompactionPartParam) MarshalJSON 

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

func (*PartCompactionPartParam) UnmarshalJSON 

func (r *PartCompactionPartParam) UnmarshalJSON(data []byte) error

type PartPatchPart 

type PartPatchPart struct {
	ID        string   `json:"id" api:"required"`
	Files     []string `json:"files" api:"required"`
	Hash      string   `json:"hash" api:"required"`
	MessageID string   `json:"messageID" api:"required"`
	SessionID string   `json:"sessionID" api:"required"`
	// Any of "patch".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Files       respjson.Field
		Hash        respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartPatchPart) RawJSON 

func (r PartPatchPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartPatchPart) UnmarshalJSON 

func (r *PartPatchPart) UnmarshalJSON(data []byte) error

type PartPatchPartParam 

type PartPatchPartParam struct {
	ID        string   `json:"id" api:"required"`
	Files     []string `json:"files,omitzero" api:"required"`
	Hash      string   `json:"hash" api:"required"`
	MessageID string   `json:"messageID" api:"required"`
	SessionID string   `json:"sessionID" api:"required"`
	// Any of "patch".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties ID, Files, Hash, MessageID, SessionID, Type are required.

func (PartPatchPartParam) MarshalJSON 

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

func (*PartPatchPartParam) UnmarshalJSON 

func (r *PartPatchPartParam) UnmarshalJSON(data []byte) error

type PartReasoningPart 

type PartReasoningPart struct {
	ID        string                `json:"id" api:"required"`
	MessageID string                `json:"messageID" api:"required"`
	SessionID string                `json:"sessionID" api:"required"`
	Text      string                `json:"text" api:"required"`
	Time      PartReasoningPartTime `json:"time" api:"required"`
	// Any of "reasoning".
	Type     string         `json:"type" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartReasoningPart) RawJSON 

func (r PartReasoningPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartReasoningPart) UnmarshalJSON 

func (r *PartReasoningPart) UnmarshalJSON(data []byte) error

type PartReasoningPartParam 

type PartReasoningPartParam struct {
	ID        string                     `json:"id" api:"required"`
	MessageID string                     `json:"messageID" api:"required"`
	SessionID string                     `json:"sessionID" api:"required"`
	Text      string                     `json:"text" api:"required"`
	Time      PartReasoningPartTimeParam `json:"time,omitzero" api:"required"`
	// Any of "reasoning".
	Type     string         `json:"type,omitzero" api:"required"`
	Metadata map[string]any `json:"metadata,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, MessageID, SessionID, Text, Time, Type are required.

func (PartReasoningPartParam) MarshalJSON 

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

func (*PartReasoningPartParam) UnmarshalJSON 

func (r *PartReasoningPartParam) UnmarshalJSON(data []byte) error

type PartReasoningPartTime 

type PartReasoningPartTime struct {
	Start int64 `json:"start" api:"required"`
	End   int64 `json:"end"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Start       respjson.Field
		End         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartReasoningPartTime) RawJSON 

func (r PartReasoningPartTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartReasoningPartTime) UnmarshalJSON 

func (r *PartReasoningPartTime) UnmarshalJSON(data []byte) error

type PartReasoningPartTimeParam 

type PartReasoningPartTimeParam struct {
	Start int64            `json:"start" api:"required"`
	End   param.Opt[int64] `json:"end,omitzero"`
	// contains filtered or unexported fields
}

The property Start is required.

func (PartReasoningPartTimeParam) MarshalJSON 

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

func (*PartReasoningPartTimeParam) UnmarshalJSON 

func (r *PartReasoningPartTimeParam) UnmarshalJSON(data []byte) error

type PartRetryPart 

type PartRetryPart struct {
	ID        string            `json:"id" api:"required"`
	Attempt   int64             `json:"attempt" api:"required"`
	Error     APIError          `json:"error" api:"required"`
	MessageID string            `json:"messageID" api:"required"`
	SessionID string            `json:"sessionID" api:"required"`
	Time      PartRetryPartTime `json:"time" api:"required"`
	// Any of "retry".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Attempt     respjson.Field
		Error       respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartRetryPart) RawJSON 

func (r PartRetryPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartRetryPart) UnmarshalJSON 

func (r *PartRetryPart) UnmarshalJSON(data []byte) error

type PartRetryPartParam 

type PartRetryPartParam struct {
	ID        string                 `json:"id" api:"required"`
	Attempt   int64                  `json:"attempt" api:"required"`
	Error     APIErrorParam          `json:"error,omitzero" api:"required"`
	MessageID string                 `json:"messageID" api:"required"`
	SessionID string                 `json:"sessionID" api:"required"`
	Time      PartRetryPartTimeParam `json:"time,omitzero" api:"required"`
	// Any of "retry".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties ID, Attempt, Error, MessageID, SessionID, Time, Type are required.

func (PartRetryPartParam) MarshalJSON 

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

func (*PartRetryPartParam) UnmarshalJSON 

func (r *PartRetryPartParam) UnmarshalJSON(data []byte) error

type PartRetryPartTime 

type PartRetryPartTime struct {
	Created int64 `json:"created" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartRetryPartTime) RawJSON 

func (r PartRetryPartTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartRetryPartTime) UnmarshalJSON 

func (r *PartRetryPartTime) UnmarshalJSON(data []byte) error

type PartRetryPartTimeParam 

type PartRetryPartTimeParam struct {
	Created int64 `json:"created" api:"required"`
	// contains filtered or unexported fields
}

The property Created is required.

func (PartRetryPartTimeParam) MarshalJSON 

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

func (*PartRetryPartTimeParam) UnmarshalJSON 

func (r *PartRetryPartTimeParam) UnmarshalJSON(data []byte) error

type PartSnapshotPart 

type PartSnapshotPart struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	Snapshot  string `json:"snapshot" api:"required"`
	// Any of "snapshot".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Snapshot    respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartSnapshotPart) RawJSON 

func (r PartSnapshotPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartSnapshotPart) UnmarshalJSON 

func (r *PartSnapshotPart) UnmarshalJSON(data []byte) error

type PartSnapshotPartParam 

type PartSnapshotPartParam struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	Snapshot  string `json:"snapshot" api:"required"`
	// Any of "snapshot".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties ID, MessageID, SessionID, Snapshot, Type are required.

func (PartSnapshotPartParam) MarshalJSON 

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

func (*PartSnapshotPartParam) UnmarshalJSON 

func (r *PartSnapshotPartParam) UnmarshalJSON(data []byte) error

type PartStepFinishPart 

type PartStepFinishPart struct {
	ID        string                   `json:"id" api:"required"`
	Cost      float64                  `json:"cost" api:"required"`
	MessageID string                   `json:"messageID" api:"required"`
	Reason    string                   `json:"reason" api:"required"`
	SessionID string                   `json:"sessionID" api:"required"`
	Tokens    PartStepFinishPartTokens `json:"tokens" api:"required"`
	// Any of "step-finish".
	Type     string `json:"type" api:"required"`
	Snapshot string `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Cost        respjson.Field
		MessageID   respjson.Field
		Reason      respjson.Field
		SessionID   respjson.Field
		Tokens      respjson.Field
		Type        respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartStepFinishPart) RawJSON 

func (r PartStepFinishPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartStepFinishPart) UnmarshalJSON 

func (r *PartStepFinishPart) UnmarshalJSON(data []byte) error

type PartStepFinishPartParam 

type PartStepFinishPartParam struct {
	ID        string                        `json:"id" api:"required"`
	Cost      float64                       `json:"cost" api:"required"`
	MessageID string                        `json:"messageID" api:"required"`
	Reason    string                        `json:"reason" api:"required"`
	SessionID string                        `json:"sessionID" api:"required"`
	Tokens    PartStepFinishPartTokensParam `json:"tokens,omitzero" api:"required"`
	// Any of "step-finish".
	Type     string            `json:"type,omitzero" api:"required"`
	Snapshot param.Opt[string] `json:"snapshot,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, Cost, MessageID, Reason, SessionID, Tokens, Type are required.

func (PartStepFinishPartParam) MarshalJSON 

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

func (*PartStepFinishPartParam) UnmarshalJSON 

func (r *PartStepFinishPartParam) UnmarshalJSON(data []byte) error

type PartStepFinishPartTokens 

type PartStepFinishPartTokens struct {
	Cache     PartStepFinishPartTokensCache `json:"cache" api:"required"`
	Input     float64                       `json:"input" api:"required"`
	Output    float64                       `json:"output" api:"required"`
	Reasoning float64                       `json:"reasoning" api:"required"`
	Total     float64                       `json:"total"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		Total       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartStepFinishPartTokens) RawJSON 

func (r PartStepFinishPartTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartStepFinishPartTokens) UnmarshalJSON 

func (r *PartStepFinishPartTokens) UnmarshalJSON(data []byte) error

type PartStepFinishPartTokensCache 

type PartStepFinishPartTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartStepFinishPartTokensCache) RawJSON 

func (r PartStepFinishPartTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartStepFinishPartTokensCache) UnmarshalJSON 

func (r *PartStepFinishPartTokensCache) UnmarshalJSON(data []byte) error

type PartStepFinishPartTokensCacheParam 

type PartStepFinishPartTokensCacheParam struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// contains filtered or unexported fields
}

The properties Read, Write are required.

func (PartStepFinishPartTokensCacheParam) MarshalJSON 

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

func (*PartStepFinishPartTokensCacheParam) UnmarshalJSON 

func (r *PartStepFinishPartTokensCacheParam) UnmarshalJSON(data []byte) error

type PartStepFinishPartTokensParam 

type PartStepFinishPartTokensParam struct {
	Cache     PartStepFinishPartTokensCacheParam `json:"cache,omitzero" api:"required"`
	Input     float64                            `json:"input" api:"required"`
	Output    float64                            `json:"output" api:"required"`
	Reasoning float64                            `json:"reasoning" api:"required"`
	Total     param.Opt[float64]                 `json:"total,omitzero"`
	// contains filtered or unexported fields
}

The properties Cache, Input, Output, Reasoning are required.

func (PartStepFinishPartTokensParam) MarshalJSON 

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

func (*PartStepFinishPartTokensParam) UnmarshalJSON 

func (r *PartStepFinishPartTokensParam) UnmarshalJSON(data []byte) error

type PartStepStartPart 

type PartStepStartPart struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "step-start".
	Type     string `json:"type" api:"required"`
	Snapshot string `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Type        respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartStepStartPart) RawJSON 

func (r PartStepStartPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartStepStartPart) UnmarshalJSON 

func (r *PartStepStartPart) UnmarshalJSON(data []byte) error

type PartStepStartPartParam 

type PartStepStartPartParam struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	// Any of "step-start".
	Type     string            `json:"type,omitzero" api:"required"`
	Snapshot param.Opt[string] `json:"snapshot,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, MessageID, SessionID, Type are required.

func (PartStepStartPartParam) MarshalJSON 

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

func (*PartStepStartPartParam) UnmarshalJSON 

func (r *PartStepStartPartParam) UnmarshalJSON(data []byte) error

type PartSubtaskPart 

type PartSubtaskPart struct {
	ID          string `json:"id" api:"required"`
	Agent       string `json:"agent" api:"required"`
	Description string `json:"description" api:"required"`
	MessageID   string `json:"messageID" api:"required"`
	Prompt      string `json:"prompt" api:"required"`
	SessionID   string `json:"sessionID" api:"required"`
	// Any of "subtask".
	Type    string               `json:"type" api:"required"`
	Command string               `json:"command"`
	Model   PartSubtaskPartModel `json:"model"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Agent       respjson.Field
		Description respjson.Field
		MessageID   respjson.Field
		Prompt      respjson.Field
		SessionID   respjson.Field
		Type        respjson.Field
		Command     respjson.Field
		Model       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartSubtaskPart) RawJSON 

func (r PartSubtaskPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartSubtaskPart) UnmarshalJSON 

func (r *PartSubtaskPart) UnmarshalJSON(data []byte) error

type PartSubtaskPartModel 

type PartSubtaskPartModel struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ModelID     respjson.Field
		ProviderID  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartSubtaskPartModel) RawJSON 

func (r PartSubtaskPartModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartSubtaskPartModel) UnmarshalJSON 

func (r *PartSubtaskPartModel) UnmarshalJSON(data []byte) error

type PartSubtaskPartModelParam 

type PartSubtaskPartModelParam struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// contains filtered or unexported fields
}

The properties ModelID, ProviderID are required.

func (PartSubtaskPartModelParam) MarshalJSON 

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

func (*PartSubtaskPartModelParam) UnmarshalJSON 

func (r *PartSubtaskPartModelParam) UnmarshalJSON(data []byte) error

type PartSubtaskPartParam 

type PartSubtaskPartParam struct {
	ID          string `json:"id" api:"required"`
	Agent       string `json:"agent" api:"required"`
	Description string `json:"description" api:"required"`
	MessageID   string `json:"messageID" api:"required"`
	Prompt      string `json:"prompt" api:"required"`
	SessionID   string `json:"sessionID" api:"required"`
	// Any of "subtask".
	Type    string                    `json:"type,omitzero" api:"required"`
	Command param.Opt[string]         `json:"command,omitzero"`
	Model   PartSubtaskPartModelParam `json:"model,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, Agent, Description, MessageID, Prompt, SessionID, Type are required.

func (PartSubtaskPartParam) MarshalJSON 

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

func (*PartSubtaskPartParam) UnmarshalJSON 

func (r *PartSubtaskPartParam) UnmarshalJSON(data []byte) error

type PartTextPart 

type PartTextPart struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	Text      string `json:"text" api:"required"`
	// Any of "text".
	Type      string           `json:"type" api:"required"`
	Ignored   bool             `json:"ignored"`
	Metadata  map[string]any   `json:"metadata"`
	Synthetic bool             `json:"synthetic"`
	Time      PartTextPartTime `json:"time"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		Ignored     respjson.Field
		Metadata    respjson.Field
		Synthetic   respjson.Field
		Time        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartTextPart) RawJSON 

func (r PartTextPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartTextPart) UnmarshalJSON 

func (r *PartTextPart) UnmarshalJSON(data []byte) error

type PartTextPartParam 

type PartTextPartParam struct {
	ID        string `json:"id" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	SessionID string `json:"sessionID" api:"required"`
	Text      string `json:"text" api:"required"`
	// Any of "text".
	Type      string                `json:"type,omitzero" api:"required"`
	Ignored   param.Opt[bool]       `json:"ignored,omitzero"`
	Synthetic param.Opt[bool]       `json:"synthetic,omitzero"`
	Metadata  map[string]any        `json:"metadata,omitzero"`
	Time      PartTextPartTimeParam `json:"time,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, MessageID, SessionID, Text, Type are required.

func (PartTextPartParam) MarshalJSON 

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

func (*PartTextPartParam) UnmarshalJSON 

func (r *PartTextPartParam) UnmarshalJSON(data []byte) error

type PartTextPartTime 

type PartTextPartTime struct {
	Start int64 `json:"start" api:"required"`
	End   int64 `json:"end"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Start       respjson.Field
		End         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartTextPartTime) RawJSON 

func (r PartTextPartTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartTextPartTime) UnmarshalJSON 

func (r *PartTextPartTime) UnmarshalJSON(data []byte) error

type PartTextPartTimeParam 

type PartTextPartTimeParam struct {
	Start int64            `json:"start" api:"required"`
	End   param.Opt[int64] `json:"end,omitzero"`
	// contains filtered or unexported fields
}

The property Start is required.

func (PartTextPartTimeParam) MarshalJSON 

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

func (*PartTextPartTimeParam) UnmarshalJSON 

func (r *PartTextPartTimeParam) UnmarshalJSON(data []byte) error

type PartToolPart 

type PartToolPart struct {
	ID        string                 `json:"id" api:"required"`
	CallID    string                 `json:"callID" api:"required"`
	MessageID string                 `json:"messageID" api:"required"`
	SessionID string                 `json:"sessionID" api:"required"`
	State     PartToolPartStateUnion `json:"state" api:"required"`
	Tool      string                 `json:"tool" api:"required"`
	// Any of "tool".
	Type     string         `json:"type" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		CallID      respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		State       respjson.Field
		Tool        respjson.Field
		Type        respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPart) RawJSON 

func (r PartToolPart) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPart) UnmarshalJSON 

func (r *PartToolPart) UnmarshalJSON(data []byte) error

type PartToolPartParam 

type PartToolPartParam struct {
	ID        string                      `json:"id" api:"required"`
	CallID    string                      `json:"callID" api:"required"`
	MessageID string                      `json:"messageID" api:"required"`
	SessionID string                      `json:"sessionID" api:"required"`
	State     PartToolPartStateUnionParam `json:"state,omitzero" api:"required"`
	Tool      string                      `json:"tool" api:"required"`
	// Any of "tool".
	Type     string         `json:"type,omitzero" api:"required"`
	Metadata map[string]any `json:"metadata,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, CallID, MessageID, SessionID, State, Tool, Type are required.

func (PartToolPartParam) MarshalJSON 

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

func (*PartToolPartParam) UnmarshalJSON 

func (r *PartToolPartParam) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateCompleted 

type PartToolPartStateToolStateCompleted struct {
	Input    map[string]any `json:"input" api:"required"`
	Metadata map[string]any `json:"metadata" api:"required"`
	Output   string         `json:"output" api:"required"`
	// Any of "completed".
	Status      string                                  `json:"status" api:"required"`
	Time        PartToolPartStateToolStateCompletedTime `json:"time" api:"required"`
	Title       string                                  `json:"title" api:"required"`
	Attachments []FilePart                              `json:"attachments"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input       respjson.Field
		Metadata    respjson.Field
		Output      respjson.Field
		Status      respjson.Field
		Time        respjson.Field
		Title       respjson.Field
		Attachments respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPartStateToolStateCompleted) RawJSON 

func (r PartToolPartStateToolStateCompleted) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateToolStateCompleted) UnmarshalJSON 

func (r *PartToolPartStateToolStateCompleted) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateCompletedParam 

type PartToolPartStateToolStateCompletedParam struct {
	Input    map[string]any `json:"input,omitzero" api:"required"`
	Metadata map[string]any `json:"metadata,omitzero" api:"required"`
	Output   string         `json:"output" api:"required"`
	// Any of "completed".
	Status      string                                       `json:"status,omitzero" api:"required"`
	Time        PartToolPartStateToolStateCompletedTimeParam `json:"time,omitzero" api:"required"`
	Title       string                                       `json:"title" api:"required"`
	Attachments []FilePartParam                              `json:"attachments,omitzero"`
	// contains filtered or unexported fields
}

The properties Input, Metadata, Output, Status, Time, Title are required.

func (PartToolPartStateToolStateCompletedParam) MarshalJSON 

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

func (*PartToolPartStateToolStateCompletedParam) UnmarshalJSON 

func (r *PartToolPartStateToolStateCompletedParam) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateCompletedTime 

type PartToolPartStateToolStateCompletedTime struct {
	End       int64 `json:"end" api:"required"`
	Start     int64 `json:"start" api:"required"`
	Compacted int64 `json:"compacted"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Start       respjson.Field
		Compacted   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPartStateToolStateCompletedTime) RawJSON 

func (r PartToolPartStateToolStateCompletedTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateToolStateCompletedTime) UnmarshalJSON 

func (r *PartToolPartStateToolStateCompletedTime) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateCompletedTimeParam 

type PartToolPartStateToolStateCompletedTimeParam struct {
	End       int64            `json:"end" api:"required"`
	Start     int64            `json:"start" api:"required"`
	Compacted param.Opt[int64] `json:"compacted,omitzero"`
	// contains filtered or unexported fields
}

The properties End, Start are required.

func (PartToolPartStateToolStateCompletedTimeParam) MarshalJSON 

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

func (*PartToolPartStateToolStateCompletedTimeParam) UnmarshalJSON 

func (r *PartToolPartStateToolStateCompletedTimeParam) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateError 

type PartToolPartStateToolStateError struct {
	Error string         `json:"error" api:"required"`
	Input map[string]any `json:"input" api:"required"`
	// Any of "error".
	Status   string                              `json:"status" api:"required"`
	Time     PartToolPartStateToolStateErrorTime `json:"time" api:"required"`
	Metadata map[string]any                      `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Error       respjson.Field
		Input       respjson.Field
		Status      respjson.Field
		Time        respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPartStateToolStateError) RawJSON 

func (r PartToolPartStateToolStateError) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateToolStateError) UnmarshalJSON 

func (r *PartToolPartStateToolStateError) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateErrorParam 

type PartToolPartStateToolStateErrorParam struct {
	Error string         `json:"error" api:"required"`
	Input map[string]any `json:"input,omitzero" api:"required"`
	// Any of "error".
	Status   string                                   `json:"status,omitzero" api:"required"`
	Time     PartToolPartStateToolStateErrorTimeParam `json:"time,omitzero" api:"required"`
	Metadata map[string]any                           `json:"metadata,omitzero"`
	// contains filtered or unexported fields
}

The properties Error, Input, Status, Time are required.

func (PartToolPartStateToolStateErrorParam) MarshalJSON 

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

func (*PartToolPartStateToolStateErrorParam) UnmarshalJSON 

func (r *PartToolPartStateToolStateErrorParam) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateErrorTime 

type PartToolPartStateToolStateErrorTime struct {
	End   int64 `json:"end" api:"required"`
	Start int64 `json:"start" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Start       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPartStateToolStateErrorTime) RawJSON 

func (r PartToolPartStateToolStateErrorTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateToolStateErrorTime) UnmarshalJSON 

func (r *PartToolPartStateToolStateErrorTime) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateErrorTimeParam 

type PartToolPartStateToolStateErrorTimeParam struct {
	End   int64 `json:"end" api:"required"`
	Start int64 `json:"start" api:"required"`
	// contains filtered or unexported fields
}

The properties End, Start are required.

func (PartToolPartStateToolStateErrorTimeParam) MarshalJSON 

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

func (*PartToolPartStateToolStateErrorTimeParam) UnmarshalJSON 

func (r *PartToolPartStateToolStateErrorTimeParam) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStatePending 

type PartToolPartStateToolStatePending struct {
	Input map[string]any `json:"input" api:"required"`
	Raw   string         `json:"raw" api:"required"`
	// Any of "pending".
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input       respjson.Field
		Raw         respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPartStateToolStatePending) RawJSON 

func (r PartToolPartStateToolStatePending) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateToolStatePending) UnmarshalJSON 

func (r *PartToolPartStateToolStatePending) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStatePendingParam 

type PartToolPartStateToolStatePendingParam struct {
	Input map[string]any `json:"input,omitzero" api:"required"`
	Raw   string         `json:"raw" api:"required"`
	// Any of "pending".
	Status string `json:"status,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Input, Raw, Status are required.

func (PartToolPartStateToolStatePendingParam) MarshalJSON 

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

func (*PartToolPartStateToolStatePendingParam) UnmarshalJSON 

func (r *PartToolPartStateToolStatePendingParam) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateRunning 

type PartToolPartStateToolStateRunning struct {
	Input map[string]any `json:"input" api:"required"`
	// Any of "running".
	Status   string                                `json:"status" api:"required"`
	Time     PartToolPartStateToolStateRunningTime `json:"time" api:"required"`
	Metadata map[string]any                        `json:"metadata"`
	Title    string                                `json:"title"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input       respjson.Field
		Status      respjson.Field
		Time        respjson.Field
		Metadata    respjson.Field
		Title       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPartStateToolStateRunning) RawJSON 

func (r PartToolPartStateToolStateRunning) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateToolStateRunning) UnmarshalJSON 

func (r *PartToolPartStateToolStateRunning) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateRunningParam 

type PartToolPartStateToolStateRunningParam struct {
	Input map[string]any `json:"input,omitzero" api:"required"`
	// Any of "running".
	Status   string                                     `json:"status,omitzero" api:"required"`
	Time     PartToolPartStateToolStateRunningTimeParam `json:"time,omitzero" api:"required"`
	Title    param.Opt[string]                          `json:"title,omitzero"`
	Metadata map[string]any                             `json:"metadata,omitzero"`
	// contains filtered or unexported fields
}

The properties Input, Status, Time are required.

func (PartToolPartStateToolStateRunningParam) MarshalJSON 

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

func (*PartToolPartStateToolStateRunningParam) UnmarshalJSON 

func (r *PartToolPartStateToolStateRunningParam) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateRunningTime 

type PartToolPartStateToolStateRunningTime struct {
	Start int64 `json:"start" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Start       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PartToolPartStateToolStateRunningTime) RawJSON 

func (r PartToolPartStateToolStateRunningTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateToolStateRunningTime) UnmarshalJSON 

func (r *PartToolPartStateToolStateRunningTime) UnmarshalJSON(data []byte) error

type PartToolPartStateToolStateRunningTimeParam 

type PartToolPartStateToolStateRunningTimeParam struct {
	Start int64 `json:"start" api:"required"`
	// contains filtered or unexported fields
}

The property Start is required.

func (PartToolPartStateToolStateRunningTimeParam) MarshalJSON 

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

func (*PartToolPartStateToolStateRunningTimeParam) UnmarshalJSON 

func (r *PartToolPartStateToolStateRunningTimeParam) UnmarshalJSON(data []byte) error

type PartToolPartStateUnion 

type PartToolPartStateUnion struct {
	Input any `json:"input"`
	// This field is from variant [PartToolPartStateToolStatePending].
	Raw    string `json:"raw"`
	Status string `json:"status"`
	// This field is a union of [PartToolPartStateToolStateRunningTime],
	// [PartToolPartStateToolStateCompletedTime], [PartToolPartStateToolStateErrorTime]
	Time     PartToolPartStateUnionTime `json:"time"`
	Metadata any                        `json:"metadata"`
	Title    string                     `json:"title"`
	// This field is from variant [PartToolPartStateToolStateCompleted].
	Output string `json:"output"`
	// This field is from variant [PartToolPartStateToolStateCompleted].
	Attachments []FilePart `json:"attachments"`
	// This field is from variant [PartToolPartStateToolStateError].
	Error string `json:"error"`
	JSON  struct {
		Input       respjson.Field
		Raw         respjson.Field
		Status      respjson.Field
		Time        respjson.Field
		Metadata    respjson.Field
		Title       respjson.Field
		Output      respjson.Field
		Attachments respjson.Field
		Error       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

PartToolPartStateUnion contains all possible properties and values from PartToolPartStateToolStatePending, PartToolPartStateToolStateRunning, PartToolPartStateToolStateCompleted, PartToolPartStateToolStateError.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (PartToolPartStateUnion) AsPartToolPartStateToolStateCompleted 

func (u PartToolPartStateUnion) AsPartToolPartStateToolStateCompleted() (v PartToolPartStateToolStateCompleted)

func (PartToolPartStateUnion) AsPartToolPartStateToolStateError 

func (u PartToolPartStateUnion) AsPartToolPartStateToolStateError() (v PartToolPartStateToolStateError)

func (PartToolPartStateUnion) AsPartToolPartStateToolStatePending 

func (u PartToolPartStateUnion) AsPartToolPartStateToolStatePending() (v PartToolPartStateToolStatePending)

func (PartToolPartStateUnion) AsPartToolPartStateToolStateRunning 

func (u PartToolPartStateUnion) AsPartToolPartStateToolStateRunning() (v PartToolPartStateToolStateRunning)

func (PartToolPartStateUnion) RawJSON 

func (u PartToolPartStateUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*PartToolPartStateUnion) UnmarshalJSON 

func (r *PartToolPartStateUnion) UnmarshalJSON(data []byte) error

type PartToolPartStateUnionParam 

type PartToolPartStateUnionParam struct {
	OfPartToolPartStateToolStatePending   *PartToolPartStateToolStatePendingParam   `json:",omitzero,inline"`
	OfPartToolPartStateToolStateRunning   *PartToolPartStateToolStateRunningParam   `json:",omitzero,inline"`
	OfPartToolPartStateToolStateCompleted *PartToolPartStateToolStateCompletedParam `json:",omitzero,inline"`
	OfPartToolPartStateToolStateError     *PartToolPartStateToolStateErrorParam     `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (PartToolPartStateUnionParam) MarshalJSON 

func (u PartToolPartStateUnionParam) MarshalJSON() ([]byte, error)

func (*PartToolPartStateUnionParam) UnmarshalJSON 

func (u *PartToolPartStateUnionParam) UnmarshalJSON(data []byte) error

type PartToolPartStateUnionTime 

type PartToolPartStateUnionTime struct {
	Start int64 `json:"start"`
	End   int64 `json:"end"`
	// This field is from variant [PartToolPartStateToolStateCompletedTime].
	Compacted int64 `json:"compacted"`
	JSON      struct {
		Start     respjson.Field
		End       respjson.Field
		Compacted respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

PartToolPartStateUnionTime is an implicit subunion of PartToolPartStateUnion. PartToolPartStateUnionTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the PartToolPartStateUnion.

func (*PartToolPartStateUnionTime) UnmarshalJSON 

func (r *PartToolPartStateUnionTime) UnmarshalJSON(data []byte) error

type PartUnion 

type PartUnion struct {
	ID        string `json:"id"`
	MessageID string `json:"messageID"`
	SessionID string `json:"sessionID"`
	Text      string `json:"text"`
	Type      string `json:"type"`
	// This field is from variant [PartTextPart].
	Ignored  bool `json:"ignored"`
	Metadata any  `json:"metadata"`
	// This field is from variant [PartTextPart].
	Synthetic bool `json:"synthetic"`
	// This field is a union of [PartTextPartTime], [PartReasoningPartTime],
	// [PartRetryPartTime]
	Time PartUnionTime `json:"time"`
	// This field is from variant [PartSubtaskPart].
	Agent string `json:"agent"`
	// This field is from variant [PartSubtaskPart].
	Description string `json:"description"`
	// This field is from variant [PartSubtaskPart].
	Prompt string `json:"prompt"`
	// This field is from variant [PartSubtaskPart].
	Command string `json:"command"`
	// This field is from variant [PartSubtaskPart].
	Model PartSubtaskPartModel `json:"model"`
	// This field is from variant [FilePart].
	Mime string `json:"mime"`
	// This field is from variant [FilePart].
	URL string `json:"url"`
	// This field is from variant [FilePart].
	Filename string `json:"filename"`
	// This field is a union of [FilePartSourceUnion], [PartAgentPartSource]
	Source PartUnionSource `json:"source"`
	// This field is from variant [PartToolPart].
	CallID string `json:"callID"`
	// This field is from variant [PartToolPart].
	State PartToolPartStateUnion `json:"state"`
	// This field is from variant [PartToolPart].
	Tool     string `json:"tool"`
	Snapshot string `json:"snapshot"`
	// This field is from variant [PartStepFinishPart].
	Cost float64 `json:"cost"`
	// This field is from variant [PartStepFinishPart].
	Reason string `json:"reason"`
	// This field is from variant [PartStepFinishPart].
	Tokens PartStepFinishPartTokens `json:"tokens"`
	// This field is from variant [PartPatchPart].
	Files []string `json:"files"`
	// This field is from variant [PartPatchPart].
	Hash string `json:"hash"`
	// This field is from variant [PartAgentPart].
	Name string `json:"name"`
	// This field is from variant [PartRetryPart].
	Attempt int64 `json:"attempt"`
	// This field is from variant [PartRetryPart].
	Error APIError `json:"error"`
	// This field is from variant [PartCompactionPart].
	Auto bool `json:"auto"`
	// This field is from variant [PartCompactionPart].
	Overflow bool `json:"overflow"`
	// This field is from variant [PartCompactionPart].
	TailStartID string `json:"tail_start_id"`
	JSON        struct {
		ID          respjson.Field
		MessageID   respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		Ignored     respjson.Field
		Metadata    respjson.Field
		Synthetic   respjson.Field
		Time        respjson.Field
		Agent       respjson.Field
		Description respjson.Field
		Prompt      respjson.Field
		Command     respjson.Field
		Model       respjson.Field
		Mime        respjson.Field
		URL         respjson.Field
		Filename    respjson.Field
		Source      respjson.Field
		CallID      respjson.Field
		State       respjson.Field
		Tool        respjson.Field
		Snapshot    respjson.Field
		Cost        respjson.Field
		Reason      respjson.Field
		Tokens      respjson.Field
		Files       respjson.Field
		Hash        respjson.Field
		Name        respjson.Field
		Attempt     respjson.Field
		Error       respjson.Field
		Auto        respjson.Field
		Overflow    respjson.Field
		TailStartID respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

PartUnion contains all possible properties and values from PartTextPart, PartSubtaskPart, PartReasoningPart, FilePart, PartToolPart, PartStepStartPart, PartStepFinishPart, PartSnapshotPart, PartPatchPart, PartAgentPart, PartRetryPart, PartCompactionPart.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (PartUnion) AsFilePart 

func (u PartUnion) AsFilePart() (v FilePart)

func (PartUnion) AsPartAgentPart 

func (u PartUnion) AsPartAgentPart() (v PartAgentPart)

func (PartUnion) AsPartCompactionPart 

func (u PartUnion) AsPartCompactionPart() (v PartCompactionPart)

func (PartUnion) AsPartPatchPart 

func (u PartUnion) AsPartPatchPart() (v PartPatchPart)

func (PartUnion) AsPartReasoningPart 

func (u PartUnion) AsPartReasoningPart() (v PartReasoningPart)

func (PartUnion) AsPartRetryPart 

func (u PartUnion) AsPartRetryPart() (v PartRetryPart)

func (PartUnion) AsPartSnapshotPart 

func (u PartUnion) AsPartSnapshotPart() (v PartSnapshotPart)

func (PartUnion) AsPartStepFinishPart 

func (u PartUnion) AsPartStepFinishPart() (v PartStepFinishPart)

func (PartUnion) AsPartStepStartPart 

func (u PartUnion) AsPartStepStartPart() (v PartStepStartPart)

func (PartUnion) AsPartSubtaskPart 

func (u PartUnion) AsPartSubtaskPart() (v PartSubtaskPart)

func (PartUnion) AsPartTextPart 

func (u PartUnion) AsPartTextPart() (v PartTextPart)

func (PartUnion) AsPartToolPart 

func (u PartUnion) AsPartToolPart() (v PartToolPart)

func (PartUnion) RawJSON 

func (u PartUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (PartUnion) ToParam 

func (r PartUnion) ToParam() PartUnionParam

ToParam converts this PartUnion to a PartUnionParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PartUnionParam.Overrides()

func (*PartUnion) UnmarshalJSON 

func (r *PartUnion) UnmarshalJSON(data []byte) error

type PartUnionParam 

type PartUnionParam struct {
	OfPartTextPart       *PartTextPartParam       `json:",omitzero,inline"`
	OfPartSubtaskPart    *PartSubtaskPartParam    `json:",omitzero,inline"`
	OfPartReasoningPart  *PartReasoningPartParam  `json:",omitzero,inline"`
	OfFilePart           *FilePartParam           `json:",omitzero,inline"`
	OfPartToolPart       *PartToolPartParam       `json:",omitzero,inline"`
	OfPartStepStartPart  *PartStepStartPartParam  `json:",omitzero,inline"`
	OfPartStepFinishPart *PartStepFinishPartParam `json:",omitzero,inline"`
	OfPartSnapshotPart   *PartSnapshotPartParam   `json:",omitzero,inline"`
	OfPartPatchPart      *PartPatchPartParam      `json:",omitzero,inline"`
	OfPartAgentPart      *PartAgentPartParam      `json:",omitzero,inline"`
	OfPartRetryPart      *PartRetryPartParam      `json:",omitzero,inline"`
	OfPartCompactionPart *PartCompactionPartParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (PartUnionParam) MarshalJSON 

func (u PartUnionParam) MarshalJSON() ([]byte, error)

func (*PartUnionParam) UnmarshalJSON 

func (u *PartUnionParam) UnmarshalJSON(data []byte) error

type PartUnionSource 

type PartUnionSource struct {
	Path string `json:"path"`
	// This field is from variant [FilePartSourceUnion].
	Text FilePartSourceText `json:"text"`
	Type string             `json:"type"`
	// This field is from variant [FilePartSourceUnion].
	Kind int64 `json:"kind"`
	// This field is from variant [FilePartSourceUnion].
	Name string `json:"name"`
	// This field is from variant [FilePartSourceUnion].
	Range Range `json:"range"`
	// This field is from variant [FilePartSourceUnion].
	ClientName string `json:"clientName"`
	// This field is from variant [FilePartSourceUnion].
	Uri string `json:"uri"`
	// This field is from variant [PartAgentPartSource].
	End int64 `json:"end"`
	// This field is from variant [PartAgentPartSource].
	Start int64 `json:"start"`
	// This field is from variant [PartAgentPartSource].
	Value string `json:"value"`
	JSON  struct {
		Path       respjson.Field
		Text       respjson.Field
		Type       respjson.Field
		Kind       respjson.Field
		Name       respjson.Field
		Range      respjson.Field
		ClientName respjson.Field
		Uri        respjson.Field
		End        respjson.Field
		Start      respjson.Field
		Value      respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

PartUnionSource is an implicit subunion of PartUnion. PartUnionSource provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the PartUnion.

func (*PartUnionSource) UnmarshalJSON 

func (r *PartUnionSource) UnmarshalJSON(data []byte) error

type PartUnionTime 

type PartUnionTime struct {
	Start int64 `json:"start"`
	End   int64 `json:"end"`
	// This field is from variant [PartRetryPartTime].
	Created int64 `json:"created"`
	JSON    struct {
		Start   respjson.Field
		End     respjson.Field
		Created respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

PartUnionTime is an implicit subunion of PartUnion. PartUnionTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the PartUnion.

func (*PartUnionTime) UnmarshalJSON 

func (r *PartUnionTime) UnmarshalJSON(data []byte) error

type PathGetParams 

type PathGetParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PathGetParams) URLQuery 

func (r PathGetParams) URLQuery() (v url.Values, err error)

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

type PathGetResponse 

type PathGetResponse struct {
	Config    string `json:"config" api:"required"`
	Directory string `json:"directory" api:"required"`
	Home      string `json:"home" api:"required"`
	State     string `json:"state" api:"required"`
	Worktree  string `json:"worktree" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Config      respjson.Field
		Directory   respjson.Field
		Home        respjson.Field
		State       respjson.Field
		Worktree    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PathGetResponse) RawJSON 

func (r PathGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*PathGetResponse) UnmarshalJSON 

func (r *PathGetResponse) UnmarshalJSON(data []byte) error

type PathService 

type PathService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

PathService contains methods and other services that help with interacting with the opencode-stainless 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 NewPathService method instead.

func NewPathService 

func NewPathService(opts ...option.RequestOption) (r PathService)

NewPathService 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 (*PathService) Get 

func (r *PathService) Get(ctx context.Context, query PathGetParams, opts ...option.RequestOption) (res *PathGetResponse, err error)

Retrieve the current working directory and related path information for the OpenCode instance.

type PermissionActionConfig 

type PermissionActionConfig string
const (
	PermissionActionConfigAsk   PermissionActionConfig = "ask"
	PermissionActionConfigAllow PermissionActionConfig = "allow"
	PermissionActionConfigDeny  PermissionActionConfig = "deny"
)

type PermissionConfigObject 

type PermissionConfigObject struct {
	Bash PermissionRuleConfig `json:"bash"`
	// Any of "ask", "allow", "deny".
	DoomLoop          PermissionActionConfig `json:"doom_loop"`
	Edit              PermissionRuleConfig   `json:"edit"`
	ExternalDirectory PermissionRuleConfig   `json:"external_directory"`
	Glob              PermissionRuleConfig   `json:"glob"`
	Grep              PermissionRuleConfig   `json:"grep"`
	List              PermissionRuleConfig   `json:"list"`
	Lsp               PermissionRuleConfig   `json:"lsp"`
	// Any of "ask", "allow", "deny".
	Question     PermissionActionConfig `json:"question"`
	Read         PermissionRuleConfig   `json:"read"`
	RepoClone    PermissionRuleConfig   `json:"repo_clone"`
	RepoOverview PermissionRuleConfig   `json:"repo_overview"`
	Skill        PermissionRuleConfig   `json:"skill"`
	Task         PermissionRuleConfig   `json:"task"`
	// Any of "ask", "allow", "deny".
	Todowrite PermissionActionConfig `json:"todowrite"`
	// Any of "ask", "allow", "deny".
	Webfetch PermissionActionConfig `json:"webfetch"`
	// Any of "ask", "allow", "deny".
	Websearch   PermissionActionConfig          `json:"websearch"`
	ExtraFields map[string]PermissionRuleConfig `json:"" api:"extrafields"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Bash              respjson.Field
		DoomLoop          respjson.Field
		Edit              respjson.Field
		ExternalDirectory respjson.Field
		Glob              respjson.Field
		Grep              respjson.Field
		List              respjson.Field
		Lsp               respjson.Field
		Question          respjson.Field
		Read              respjson.Field
		RepoClone         respjson.Field
		RepoOverview      respjson.Field
		Skill             respjson.Field
		Task              respjson.Field
		Todowrite         respjson.Field
		Webfetch          respjson.Field
		Websearch         respjson.Field
		ExtraFields       map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PermissionConfigObject) RawJSON 

func (r PermissionConfigObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*PermissionConfigObject) UnmarshalJSON 

func (r *PermissionConfigObject) UnmarshalJSON(data []byte) error

type PermissionConfigObjectParam 

type PermissionConfigObjectParam struct {
	Bash PermissionRuleConfig `json:"bash,omitzero"`
	// Any of "ask", "allow", "deny".
	DoomLoop          PermissionActionConfig `json:"doom_loop,omitzero"`
	Edit              PermissionRuleConfig   `json:"edit,omitzero"`
	ExternalDirectory PermissionRuleConfig   `json:"external_directory,omitzero"`
	Glob              PermissionRuleConfig   `json:"glob,omitzero"`
	Grep              PermissionRuleConfig   `json:"grep,omitzero"`
	List              PermissionRuleConfig   `json:"list,omitzero"`
	Lsp               PermissionRuleConfig   `json:"lsp,omitzero"`
	// Any of "ask", "allow", "deny".
	Question     PermissionActionConfig `json:"question,omitzero"`
	Read         PermissionRuleConfig   `json:"read,omitzero"`
	RepoClone    PermissionRuleConfig   `json:"repo_clone,omitzero"`
	RepoOverview PermissionRuleConfig   `json:"repo_overview,omitzero"`
	Skill        PermissionRuleConfig   `json:"skill,omitzero"`
	Task         PermissionRuleConfig   `json:"task,omitzero"`
	// Any of "ask", "allow", "deny".
	Todowrite PermissionActionConfig `json:"todowrite,omitzero"`
	// Any of "ask", "allow", "deny".
	Webfetch PermissionActionConfig `json:"webfetch,omitzero"`
	// Any of "ask", "allow", "deny".
	Websearch   PermissionActionConfig          `json:"websearch,omitzero"`
	ExtraFields map[string]PermissionRuleConfig `json:"-"`
	// contains filtered or unexported fields
}

func (PermissionConfigObjectParam) MarshalJSON 

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

func (*PermissionConfigObjectParam) UnmarshalJSON 

func (r *PermissionConfigObjectParam) UnmarshalJSON(data []byte) error

type PermissionConfigUnion 

type PermissionConfigUnion struct {
	// This field will be present if the value is a [PermissionActionConfig] instead of
	// an object.
	OfPermissionActionConfig PermissionActionConfig `json:",inline"`
	// This field is from variant [PermissionConfigObject].
	Bash PermissionRuleConfig `json:"bash"`
	// This field is from variant [PermissionConfigObject].
	DoomLoop PermissionActionConfig `json:"doom_loop"`
	// This field is from variant [PermissionConfigObject].
	Edit PermissionRuleConfig `json:"edit"`
	// This field is from variant [PermissionConfigObject].
	ExternalDirectory PermissionRuleConfig `json:"external_directory"`
	// This field is from variant [PermissionConfigObject].
	Glob PermissionRuleConfig `json:"glob"`
	// This field is from variant [PermissionConfigObject].
	Grep PermissionRuleConfig `json:"grep"`
	// This field is from variant [PermissionConfigObject].
	List PermissionRuleConfig `json:"list"`
	// This field is from variant [PermissionConfigObject].
	Lsp PermissionRuleConfig `json:"lsp"`
	// This field is from variant [PermissionConfigObject].
	Question PermissionActionConfig `json:"question"`
	// This field is from variant [PermissionConfigObject].
	Read PermissionRuleConfig `json:"read"`
	// This field is from variant [PermissionConfigObject].
	RepoClone PermissionRuleConfig `json:"repo_clone"`
	// This field is from variant [PermissionConfigObject].
	RepoOverview PermissionRuleConfig `json:"repo_overview"`
	// This field is from variant [PermissionConfigObject].
	Skill PermissionRuleConfig `json:"skill"`
	// This field is from variant [PermissionConfigObject].
	Task PermissionRuleConfig `json:"task"`
	// This field is from variant [PermissionConfigObject].
	Todowrite PermissionActionConfig `json:"todowrite"`
	// This field is from variant [PermissionConfigObject].
	Webfetch PermissionActionConfig `json:"webfetch"`
	// This field is from variant [PermissionConfigObject].
	Websearch PermissionActionConfig `json:"websearch"`
	JSON      struct {
		OfPermissionActionConfig respjson.Field
		Bash                     respjson.Field
		DoomLoop                 respjson.Field
		Edit                     respjson.Field
		ExternalDirectory        respjson.Field
		Glob                     respjson.Field
		Grep                     respjson.Field
		List                     respjson.Field
		Lsp                      respjson.Field
		Question                 respjson.Field
		Read                     respjson.Field
		RepoClone                respjson.Field
		RepoOverview             respjson.Field
		Skill                    respjson.Field
		Task                     respjson.Field
		Todowrite                respjson.Field
		Webfetch                 respjson.Field
		Websearch                respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

PermissionConfigUnion contains all possible properties and values from PermissionActionConfig, PermissionConfigObject.

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfPermissionActionConfig]

func (PermissionConfigUnion) AsPermissionActionConfig 

func (u PermissionConfigUnion) AsPermissionActionConfig() (v PermissionActionConfig)

func (PermissionConfigUnion) AsPermissionConfigObject 

func (u PermissionConfigUnion) AsPermissionConfigObject() (v PermissionConfigObject)

func (PermissionConfigUnion) RawJSON 

func (u PermissionConfigUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (PermissionConfigUnion) ToParam 

func (r PermissionConfigUnion) ToParam() PermissionConfigUnionParam

ToParam converts this PermissionConfigUnion to a PermissionConfigUnionParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PermissionConfigUnionParam.Overrides()

func (*PermissionConfigUnion) UnmarshalJSON 

func (r *PermissionConfigUnion) UnmarshalJSON(data []byte) error

type PermissionConfigUnionParam 

type PermissionConfigUnionParam struct {
	// Check if union is this variant with
	// !param.IsOmitted(union.OfPermissionActionConfig)
	OfPermissionActionConfig param.Opt[PermissionActionConfig] `json:",omitzero,inline"`
	OfPermissionConfigObject *PermissionConfigObjectParam      `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (PermissionConfigUnionParam) MarshalJSON 

func (u PermissionConfigUnionParam) MarshalJSON() ([]byte, error)

func (*PermissionConfigUnionParam) UnmarshalJSON 

func (u *PermissionConfigUnionParam) UnmarshalJSON(data []byte) error

type PermissionListPendingParams 

type PermissionListPendingParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PermissionListPendingParams) URLQuery 

func (r PermissionListPendingParams) URLQuery() (v url.Values, err error)

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

type PermissionRequest 

type PermissionRequest struct {
	ID         string                `json:"id" api:"required"`
	Always     []string              `json:"always" api:"required"`
	Metadata   map[string]any        `json:"metadata" api:"required"`
	Patterns   []string              `json:"patterns" api:"required"`
	Permission string                `json:"permission" api:"required"`
	SessionID  string                `json:"sessionID" api:"required"`
	Tool       PermissionRequestTool `json:"tool"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Always      respjson.Field
		Metadata    respjson.Field
		Patterns    respjson.Field
		Permission  respjson.Field
		SessionID   respjson.Field
		Tool        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PermissionRequest) RawJSON 

func (r PermissionRequest) RawJSON() string

Returns the unmodified JSON received from the API

func (*PermissionRequest) UnmarshalJSON 

func (r *PermissionRequest) UnmarshalJSON(data []byte) error

type PermissionRequestTool 

type PermissionRequestTool struct {
	CallID    string `json:"callID" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		MessageID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PermissionRequestTool) RawJSON 

func (r PermissionRequestTool) RawJSON() string

Returns the unmodified JSON received from the API

func (*PermissionRequestTool) UnmarshalJSON 

func (r *PermissionRequestTool) UnmarshalJSON(data []byte) error

type PermissionRespondParams 

type PermissionRespondParams struct {
	// Any of "once", "always", "reject".
	Reply     PermissionRespondParamsReply `json:"reply,omitzero" api:"required"`
	Directory param.Opt[string]            `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]            `query:"workspace,omitzero" json:"-"`
	Message   param.Opt[string]            `json:"message,omitzero"`
	// contains filtered or unexported fields
}

func (PermissionRespondParams) MarshalJSON 

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

func (PermissionRespondParams) URLQuery 

func (r PermissionRespondParams) URLQuery() (v url.Values, err error)

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

func (*PermissionRespondParams) UnmarshalJSON 

func (r *PermissionRespondParams) UnmarshalJSON(data []byte) error

type PermissionRespondParamsReply 

type PermissionRespondParamsReply string
const (
	PermissionRespondParamsReplyOnce   PermissionRespondParamsReply = "once"
	PermissionRespondParamsReplyAlways PermissionRespondParamsReply = "always"
	PermissionRespondParamsReplyReject PermissionRespondParamsReply = "reject"
)

type PermissionRule 

type PermissionRule struct {
	// Any of "allow", "deny", "ask".
	Action     PermissionRuleAction `json:"action" api:"required"`
	Pattern    string               `json:"pattern" api:"required"`
	Permission string               `json:"permission" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Action      respjson.Field
		Pattern     respjson.Field
		Permission  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PermissionRule) RawJSON 

func (r PermissionRule) RawJSON() string

Returns the unmodified JSON received from the API

func (PermissionRule) ToParam 

func (r PermissionRule) ToParam() PermissionRuleParam

ToParam converts this PermissionRule to a PermissionRuleParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PermissionRuleParam.Overrides()

func (*PermissionRule) UnmarshalJSON 

func (r *PermissionRule) UnmarshalJSON(data []byte) error

type PermissionRuleAction 

type PermissionRuleAction string
const (
	PermissionRuleActionAllow PermissionRuleAction = "allow"
	PermissionRuleActionDeny  PermissionRuleAction = "deny"
	PermissionRuleActionAsk   PermissionRuleAction = "ask"
)

type PermissionRuleConfig 

type PermissionRuleConfig map[string]PermissionActionConfig

type PermissionRuleParam 

type PermissionRuleParam struct {
	// Any of "allow", "deny", "ask".
	Action     PermissionRuleAction `json:"action,omitzero" api:"required"`
	Pattern    string               `json:"pattern" api:"required"`
	Permission string               `json:"permission" api:"required"`
	// contains filtered or unexported fields
}

The properties Action, Pattern, Permission are required.

func (PermissionRuleParam) MarshalJSON 

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

func (*PermissionRuleParam) UnmarshalJSON 

func (r *PermissionRuleParam) UnmarshalJSON(data []byte) error

type PermissionService 

type PermissionService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi permission routes.

PermissionService contains methods and other services that help with interacting with the opencode-stainless 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 NewPermissionService method instead.

func NewPermissionService 

func NewPermissionService(opts ...option.RequestOption) (r PermissionService)

NewPermissionService 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 (*PermissionService) ListPending 

func (r *PermissionService) ListPending(ctx context.Context, query PermissionListPendingParams, opts ...option.RequestOption) (res *[]PermissionRequest, err error)

Get all pending permission requests across all sessions.

func (*PermissionService) Respond 

func (r *PermissionService) Respond(ctx context.Context, requestID string, params PermissionRespondParams, opts ...option.RequestOption) (res *bool, err error)

Approve or deny a permission request from the AI assistant.

type Project 

type Project struct {
	ID        string          `json:"id" api:"required"`
	Sandboxes []string        `json:"sandboxes" api:"required"`
	Time      ProjectTime     `json:"time" api:"required"`
	Worktree  string          `json:"worktree" api:"required"`
	Commands  ProjectCommands `json:"commands"`
	Icon      ProjectIcon     `json:"icon"`
	Name      string          `json:"name"`
	// Any of "git".
	Vcs ProjectVcs `json:"vcs"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Sandboxes   respjson.Field
		Time        respjson.Field
		Worktree    respjson.Field
		Commands    respjson.Field
		Icon        respjson.Field
		Name        respjson.Field
		Vcs         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Project) RawJSON 

func (r Project) RawJSON() string

Returns the unmodified JSON received from the API

func (*Project) UnmarshalJSON 

func (r *Project) UnmarshalJSON(data []byte) error

type ProjectCommands 

type ProjectCommands struct {
	// Startup script to run when creating a new workspace (worktree)
	Start string `json:"start"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Start       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProjectCommands) RawJSON 

func (r ProjectCommands) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProjectCommands) UnmarshalJSON 

func (r *ProjectCommands) UnmarshalJSON(data []byte) error

type ProjectGetCurrentParams 

type ProjectGetCurrentParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ProjectGetCurrentParams) URLQuery 

func (r ProjectGetCurrentParams) URLQuery() (v url.Values, err error)

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

type ProjectGitInitializeParams 

type ProjectGitInitializeParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ProjectGitInitializeParams) URLQuery 

func (r ProjectGitInitializeParams) URLQuery() (v url.Values, err error)

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

type ProjectGitService 

type ProjectGitService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi project routes.

ProjectGitService contains methods and other services that help with interacting with the opencode-stainless 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 NewProjectGitService method instead.

func NewProjectGitService 

func NewProjectGitService(opts ...option.RequestOption) (r ProjectGitService)

NewProjectGitService 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 (*ProjectGitService) Initialize 

func (r *ProjectGitService) Initialize(ctx context.Context, body ProjectGitInitializeParams, opts ...option.RequestOption) (res *Project, err error)

Create a git repository for the current project and return the refreshed project info.

type ProjectIcon 

type ProjectIcon struct {
	Color    string `json:"color"`
	Override string `json:"override"`
	URL      string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Color       respjson.Field
		Override    respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProjectIcon) RawJSON 

func (r ProjectIcon) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProjectIcon) UnmarshalJSON 

func (r *ProjectIcon) UnmarshalJSON(data []byte) error

type ProjectListParams 

type ProjectListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ProjectListParams) URLQuery 

func (r ProjectListParams) URLQuery() (v url.Values, err error)

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

type ProjectService 

type ProjectService struct {

	// Experimental HttpApi project routes.
	Git ProjectGitService
	// contains filtered or unexported fields
}

Experimental HttpApi project routes.

ProjectService contains methods and other services that help with interacting with the opencode-stainless 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 NewProjectService method instead.

func NewProjectService 

func NewProjectService(opts ...option.RequestOption) (r ProjectService)

NewProjectService 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 (*ProjectService) GetCurrent 

func (r *ProjectService) GetCurrent(ctx context.Context, query ProjectGetCurrentParams, opts ...option.RequestOption) (res *Project, err error)

Retrieve the currently active project that OpenCode is working with.

func (*ProjectService) List 

func (r *ProjectService) List(ctx context.Context, query ProjectListParams, opts ...option.RequestOption) (res *[]Project, err error)

Get a list of projects that have been opened with OpenCode.

func (*ProjectService) Update 

func (r *ProjectService) Update(ctx context.Context, projectID string, params ProjectUpdateParams, opts ...option.RequestOption) (res *Project, err error)

Update project properties such as name, icon, and commands.

type ProjectTime 

type ProjectTime struct {
	Created     int64 `json:"created" api:"required"`
	Updated     int64 `json:"updated" api:"required"`
	Initialized int64 `json:"initialized"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Updated     respjson.Field
		Initialized respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProjectTime) RawJSON 

func (r ProjectTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProjectTime) UnmarshalJSON 

func (r *ProjectTime) UnmarshalJSON(data []byte) error

type ProjectUpdateParams 

type ProjectUpdateParams struct {
	Directory param.Opt[string]           `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]           `query:"workspace,omitzero" json:"-"`
	Name      param.Opt[string]           `json:"name,omitzero"`
	Commands  ProjectUpdateParamsCommands `json:"commands,omitzero"`
	Icon      ProjectUpdateParamsIcon     `json:"icon,omitzero"`
	// contains filtered or unexported fields
}

func (ProjectUpdateParams) MarshalJSON 

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

func (ProjectUpdateParams) URLQuery 

func (r ProjectUpdateParams) URLQuery() (v url.Values, err error)

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

func (*ProjectUpdateParams) UnmarshalJSON 

func (r *ProjectUpdateParams) UnmarshalJSON(data []byte) error

type ProjectUpdateParamsCommands 

type ProjectUpdateParamsCommands struct {
	// Startup script to run when creating a new workspace (worktree)
	Start param.Opt[string] `json:"start,omitzero"`
	// contains filtered or unexported fields
}

func (ProjectUpdateParamsCommands) MarshalJSON 

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

func (*ProjectUpdateParamsCommands) UnmarshalJSON 

func (r *ProjectUpdateParamsCommands) UnmarshalJSON(data []byte) error

type ProjectUpdateParamsIcon 

type ProjectUpdateParamsIcon struct {
	Color    param.Opt[string] `json:"color,omitzero"`
	Override param.Opt[string] `json:"override,omitzero"`
	URL      param.Opt[string] `json:"url,omitzero"`
	// contains filtered or unexported fields
}

func (ProjectUpdateParamsIcon) MarshalJSON 

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

func (*ProjectUpdateParamsIcon) UnmarshalJSON 

func (r *ProjectUpdateParamsIcon) UnmarshalJSON(data []byte) error

type ProjectVcs 

type ProjectVcs string
const (
	ProjectVcsGit ProjectVcs = "git"
)

type Prompt 

type Prompt struct {
	Text       string                      `json:"text" api:"required"`
	Agents     []PromptAgentAttachment     `json:"agents"`
	Files      []PromptFileAttachment      `json:"files"`
	References []PromptReferenceAttachment `json:"references"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		Agents      respjson.Field
		Files       respjson.Field
		References  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Prompt) RawJSON 

func (r Prompt) RawJSON() string

Returns the unmodified JSON received from the API

func (Prompt) ToParam 

func (r Prompt) ToParam() PromptParam

ToParam converts this Prompt to a PromptParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PromptParam.Overrides()

func (*Prompt) UnmarshalJSON 

func (r *Prompt) UnmarshalJSON(data []byte) error

type PromptAgentAttachment 

type PromptAgentAttachment struct {
	Name   string       `json:"name" api:"required"`
	Source PromptSource `json:"source"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Name        respjson.Field
		Source      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PromptAgentAttachment) RawJSON 

func (r PromptAgentAttachment) RawJSON() string

Returns the unmodified JSON received from the API

func (PromptAgentAttachment) ToParam 

func (r PromptAgentAttachment) ToParam() PromptAgentAttachmentParam

ToParam converts this PromptAgentAttachment to a PromptAgentAttachmentParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PromptAgentAttachmentParam.Overrides()

func (*PromptAgentAttachment) UnmarshalJSON 

func (r *PromptAgentAttachment) UnmarshalJSON(data []byte) error

type PromptAgentAttachmentParam 

type PromptAgentAttachmentParam struct {
	Name   string            `json:"name" api:"required"`
	Source PromptSourceParam `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The property Name is required.

func (PromptAgentAttachmentParam) MarshalJSON 

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

func (*PromptAgentAttachmentParam) UnmarshalJSON 

func (r *PromptAgentAttachmentParam) UnmarshalJSON(data []byte) error

type PromptFileAttachment 

type PromptFileAttachment struct {
	Mime        string       `json:"mime" api:"required"`
	Uri         string       `json:"uri" api:"required"`
	Description string       `json:"description"`
	Name        string       `json:"name"`
	Source      PromptSource `json:"source"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Mime        respjson.Field
		Uri         respjson.Field
		Description respjson.Field
		Name        respjson.Field
		Source      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PromptFileAttachment) RawJSON 

func (r PromptFileAttachment) RawJSON() string

Returns the unmodified JSON received from the API

func (PromptFileAttachment) ToParam 

func (r PromptFileAttachment) ToParam() PromptFileAttachmentParam

ToParam converts this PromptFileAttachment to a PromptFileAttachmentParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PromptFileAttachmentParam.Overrides()

func (*PromptFileAttachment) UnmarshalJSON 

func (r *PromptFileAttachment) UnmarshalJSON(data []byte) error

type PromptFileAttachmentParam 

type PromptFileAttachmentParam struct {
	Mime        string            `json:"mime" api:"required"`
	Uri         string            `json:"uri" api:"required"`
	Description param.Opt[string] `json:"description,omitzero"`
	Name        param.Opt[string] `json:"name,omitzero"`
	Source      PromptSourceParam `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The properties Mime, Uri are required.

func (PromptFileAttachmentParam) MarshalJSON 

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

func (*PromptFileAttachmentParam) UnmarshalJSON 

func (r *PromptFileAttachmentParam) UnmarshalJSON(data []byte) error

type PromptParam 

type PromptParam struct {
	Text       string                           `json:"text" api:"required"`
	Agents     []PromptAgentAttachmentParam     `json:"agents,omitzero"`
	Files      []PromptFileAttachmentParam      `json:"files,omitzero"`
	References []PromptReferenceAttachmentParam `json:"references,omitzero"`
	// contains filtered or unexported fields
}

The property Text is required.

func (PromptParam) MarshalJSON 

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

func (*PromptParam) UnmarshalJSON 

func (r *PromptParam) UnmarshalJSON(data []byte) error

type PromptReferenceAttachment 

type PromptReferenceAttachment struct {
	// Any of "local", "git", "invalid".
	Kind       PromptReferenceAttachmentKind `json:"kind" api:"required"`
	Name       string                        `json:"name" api:"required"`
	Branch     string                        `json:"branch"`
	Problem    string                        `json:"problem"`
	Repository string                        `json:"repository"`
	Source     PromptSource                  `json:"source"`
	Target     string                        `json:"target"`
	TargetUri  string                        `json:"targetUri"`
	Uri        string                        `json:"uri"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Kind        respjson.Field
		Name        respjson.Field
		Branch      respjson.Field
		Problem     respjson.Field
		Repository  respjson.Field
		Source      respjson.Field
		Target      respjson.Field
		TargetUri   respjson.Field
		Uri         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PromptReferenceAttachment) RawJSON 

func (r PromptReferenceAttachment) RawJSON() string

Returns the unmodified JSON received from the API

func (PromptReferenceAttachment) ToParam 

func (r PromptReferenceAttachment) ToParam() PromptReferenceAttachmentParam

ToParam converts this PromptReferenceAttachment to a PromptReferenceAttachmentParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PromptReferenceAttachmentParam.Overrides()

func (*PromptReferenceAttachment) UnmarshalJSON 

func (r *PromptReferenceAttachment) UnmarshalJSON(data []byte) error

type PromptReferenceAttachmentKind 

type PromptReferenceAttachmentKind string
const (
	PromptReferenceAttachmentKindLocal   PromptReferenceAttachmentKind = "local"
	PromptReferenceAttachmentKindGit     PromptReferenceAttachmentKind = "git"
	PromptReferenceAttachmentKindInvalid PromptReferenceAttachmentKind = "invalid"
)

type PromptReferenceAttachmentParam 

type PromptReferenceAttachmentParam struct {
	// Any of "local", "git", "invalid".
	Kind       PromptReferenceAttachmentKind `json:"kind,omitzero" api:"required"`
	Name       string                        `json:"name" api:"required"`
	Branch     param.Opt[string]             `json:"branch,omitzero"`
	Problem    param.Opt[string]             `json:"problem,omitzero"`
	Repository param.Opt[string]             `json:"repository,omitzero"`
	Target     param.Opt[string]             `json:"target,omitzero"`
	TargetUri  param.Opt[string]             `json:"targetUri,omitzero"`
	Uri        param.Opt[string]             `json:"uri,omitzero"`
	Source     PromptSourceParam             `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The properties Kind, Name are required.

func (PromptReferenceAttachmentParam) MarshalJSON 

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

func (*PromptReferenceAttachmentParam) UnmarshalJSON 

func (r *PromptReferenceAttachmentParam) UnmarshalJSON(data []byte) error

type PromptSource 

type PromptSource struct {
	End   float64 `json:"end" api:"required"`
	Start float64 `json:"start" api:"required"`
	Text  string  `json:"text" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Start       respjson.Field
		Text        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PromptSource) RawJSON 

func (r PromptSource) RawJSON() string

Returns the unmodified JSON received from the API

func (PromptSource) ToParam 

func (r PromptSource) ToParam() PromptSourceParam

ToParam converts this PromptSource to a PromptSourceParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with PromptSourceParam.Overrides()

func (*PromptSource) UnmarshalJSON 

func (r *PromptSource) UnmarshalJSON(data []byte) error

type PromptSourceParam 

type PromptSourceParam struct {
	End   float64 `json:"end" api:"required"`
	Start float64 `json:"start" api:"required"`
	Text  string  `json:"text" api:"required"`
	// contains filtered or unexported fields
}

The properties End, Start, Text are required.

func (PromptSourceParam) MarshalJSON 

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

func (*PromptSourceParam) UnmarshalJSON 

func (r *PromptSourceParam) UnmarshalJSON(data []byte) error

type Provider 

type Provider struct {
	ID      string                   `json:"id" api:"required"`
	Env     []string                 `json:"env" api:"required"`
	Models  map[string]ProviderModel `json:"models" api:"required"`
	Name    string                   `json:"name" api:"required"`
	Options map[string]any           `json:"options" api:"required"`
	// Any of "env", "config", "custom", "api".
	Source ProviderSource `json:"source" api:"required"`
	Key    string         `json:"key"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Env         respjson.Field
		Models      respjson.Field
		Name        respjson.Field
		Options     respjson.Field
		Source      respjson.Field
		Key         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Provider) RawJSON 

func (r Provider) RawJSON() string

Returns the unmodified JSON received from the API

func (*Provider) UnmarshalJSON 

func (r *Provider) UnmarshalJSON(data []byte) error

type ProviderAuthError 

type ProviderAuthError struct {
	Data ProviderAuthErrorData `json:"data" api:"required"`
	// Any of "ProviderAuthError".
	Name ProviderAuthErrorName `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderAuthError) RawJSON 

func (r ProviderAuthError) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderAuthError) UnmarshalJSON 

func (r *ProviderAuthError) UnmarshalJSON(data []byte) error

type ProviderAuthErrorData 

type ProviderAuthErrorData struct {
	Message    string `json:"message" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		ProviderID  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderAuthErrorData) RawJSON 

func (r ProviderAuthErrorData) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderAuthErrorData) UnmarshalJSON 

func (r *ProviderAuthErrorData) UnmarshalJSON(data []byte) error

type ProviderAuthErrorName 

type ProviderAuthErrorName string
const (
	ProviderAuthErrorNameProviderAuthError ProviderAuthErrorName = "ProviderAuthError"
)

type ProviderGetAuthMethodsParams 

type ProviderGetAuthMethodsParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ProviderGetAuthMethodsParams) URLQuery 

func (r ProviderGetAuthMethodsParams) URLQuery() (v url.Values, err error)

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

type ProviderGetAuthMethodsResponse 

type ProviderGetAuthMethodsResponse map[string][]ProviderGetAuthMethodsResponseItem

type ProviderGetAuthMethodsResponseItem 

type ProviderGetAuthMethodsResponseItem struct {
	Label string `json:"label" api:"required"`
	// Any of "oauth", "api".
	Type    string                                          `json:"type" api:"required"`
	Prompts []ProviderGetAuthMethodsResponseItemPromptUnion `json:"prompts"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Label       respjson.Field
		Type        respjson.Field
		Prompts     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderGetAuthMethodsResponseItem) RawJSON 

func (r ProviderGetAuthMethodsResponseItem) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderGetAuthMethodsResponseItem) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItem) UnmarshalJSON(data []byte) error

type ProviderGetAuthMethodsResponseItemPromptObject 

type ProviderGetAuthMethodsResponseItemPromptObject struct {
	Key     string `json:"key" api:"required"`
	Message string `json:"message" api:"required"`
	// Any of "text".
	Type        string                                             `json:"type" api:"required"`
	Placeholder string                                             `json:"placeholder"`
	When        ProviderGetAuthMethodsResponseItemPromptObjectWhen `json:"when"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Key         respjson.Field
		Message     respjson.Field
		Type        respjson.Field
		Placeholder respjson.Field
		When        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderGetAuthMethodsResponseItemPromptObject) RawJSON 

func (r ProviderGetAuthMethodsResponseItemPromptObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderGetAuthMethodsResponseItemPromptObject) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItemPromptObject) UnmarshalJSON(data []byte) error

type ProviderGetAuthMethodsResponseItemPromptObject2 

type ProviderGetAuthMethodsResponseItemPromptObject2 struct {
	Key     string                                                  `json:"key" api:"required"`
	Message string                                                  `json:"message" api:"required"`
	Options []ProviderGetAuthMethodsResponseItemPromptObject2Option `json:"options" api:"required"`
	// Any of "select".
	Type string                                              `json:"type" api:"required"`
	When ProviderGetAuthMethodsResponseItemPromptObject2When `json:"when"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Key         respjson.Field
		Message     respjson.Field
		Options     respjson.Field
		Type        respjson.Field
		When        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderGetAuthMethodsResponseItemPromptObject2) RawJSON 

func (r ProviderGetAuthMethodsResponseItemPromptObject2) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderGetAuthMethodsResponseItemPromptObject2) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItemPromptObject2) UnmarshalJSON(data []byte) error

type ProviderGetAuthMethodsResponseItemPromptObject2Option 

type ProviderGetAuthMethodsResponseItemPromptObject2Option struct {
	Label string `json:"label" api:"required"`
	Value string `json:"value" api:"required"`
	Hint  string `json:"hint"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Label       respjson.Field
		Value       respjson.Field
		Hint        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderGetAuthMethodsResponseItemPromptObject2Option) RawJSON 

func (r ProviderGetAuthMethodsResponseItemPromptObject2Option) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderGetAuthMethodsResponseItemPromptObject2Option) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItemPromptObject2Option) UnmarshalJSON(data []byte) error

type ProviderGetAuthMethodsResponseItemPromptObject2When 

type ProviderGetAuthMethodsResponseItemPromptObject2When struct {
	Key string `json:"key" api:"required"`
	// Any of "eq", "neq".
	Op    string `json:"op" api:"required"`
	Value string `json:"value" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Key         respjson.Field
		Op          respjson.Field
		Value       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderGetAuthMethodsResponseItemPromptObject2When) RawJSON 

func (r ProviderGetAuthMethodsResponseItemPromptObject2When) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderGetAuthMethodsResponseItemPromptObject2When) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItemPromptObject2When) UnmarshalJSON(data []byte) error

type ProviderGetAuthMethodsResponseItemPromptObjectWhen 

type ProviderGetAuthMethodsResponseItemPromptObjectWhen struct {
	Key string `json:"key" api:"required"`
	// Any of "eq", "neq".
	Op    string `json:"op" api:"required"`
	Value string `json:"value" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Key         respjson.Field
		Op          respjson.Field
		Value       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderGetAuthMethodsResponseItemPromptObjectWhen) RawJSON 

func (r ProviderGetAuthMethodsResponseItemPromptObjectWhen) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderGetAuthMethodsResponseItemPromptObjectWhen) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItemPromptObjectWhen) UnmarshalJSON(data []byte) error

type ProviderGetAuthMethodsResponseItemPromptUnion 

type ProviderGetAuthMethodsResponseItemPromptUnion struct {
	Key     string `json:"key"`
	Message string `json:"message"`
	Type    string `json:"type"`
	// This field is from variant [ProviderGetAuthMethodsResponseItemPromptObject].
	Placeholder string `json:"placeholder"`
	// This field is a union of [ProviderGetAuthMethodsResponseItemPromptObjectWhen],
	// [ProviderGetAuthMethodsResponseItemPromptObject2When]
	When ProviderGetAuthMethodsResponseItemPromptUnionWhen `json:"when"`
	// This field is from variant [ProviderGetAuthMethodsResponseItemPromptObject2].
	Options []ProviderGetAuthMethodsResponseItemPromptObject2Option `json:"options"`
	JSON    struct {
		Key         respjson.Field
		Message     respjson.Field
		Type        respjson.Field
		Placeholder respjson.Field
		When        respjson.Field
		Options     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ProviderGetAuthMethodsResponseItemPromptUnion contains all possible properties and values from ProviderGetAuthMethodsResponseItemPromptObject, ProviderGetAuthMethodsResponseItemPromptObject2.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (ProviderGetAuthMethodsResponseItemPromptUnion) AsProviderGetAuthMethodsResponseItemPromptObject 

func (u ProviderGetAuthMethodsResponseItemPromptUnion) AsProviderGetAuthMethodsResponseItemPromptObject() (v ProviderGetAuthMethodsResponseItemPromptObject)

func (ProviderGetAuthMethodsResponseItemPromptUnion) AsProviderGetAuthMethodsResponseItemPromptObject2 

func (u ProviderGetAuthMethodsResponseItemPromptUnion) AsProviderGetAuthMethodsResponseItemPromptObject2() (v ProviderGetAuthMethodsResponseItemPromptObject2)

func (ProviderGetAuthMethodsResponseItemPromptUnion) RawJSON 

func (u ProviderGetAuthMethodsResponseItemPromptUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderGetAuthMethodsResponseItemPromptUnion) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItemPromptUnion) UnmarshalJSON(data []byte) error

type ProviderGetAuthMethodsResponseItemPromptUnionWhen 

type ProviderGetAuthMethodsResponseItemPromptUnionWhen struct {
	Key   string `json:"key"`
	Op    string `json:"op"`
	Value string `json:"value"`
	JSON  struct {
		Key   respjson.Field
		Op    respjson.Field
		Value respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ProviderGetAuthMethodsResponseItemPromptUnionWhen is an implicit subunion of ProviderGetAuthMethodsResponseItemPromptUnion. ProviderGetAuthMethodsResponseItemPromptUnionWhen provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the ProviderGetAuthMethodsResponseItemPromptUnion.

func (*ProviderGetAuthMethodsResponseItemPromptUnionWhen) UnmarshalJSON 

func (r *ProviderGetAuthMethodsResponseItemPromptUnionWhen) UnmarshalJSON(data []byte) error

type ProviderListParams 

type ProviderListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (ProviderListParams) URLQuery 

func (r ProviderListParams) URLQuery() (v url.Values, err error)

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

type ProviderListResponse 

type ProviderListResponse struct {
	All       []Provider        `json:"all" api:"required"`
	Connected []string          `json:"connected" api:"required"`
	Default   map[string]string `json:"default" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		All         respjson.Field
		Connected   respjson.Field
		Default     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

List of providers

func (ProviderListResponse) RawJSON 

func (r ProviderListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderListResponse) UnmarshalJSON 

func (r *ProviderListResponse) UnmarshalJSON(data []byte) error

type ProviderModel 

type ProviderModel struct {
	ID           string                    `json:"id" api:"required"`
	API          ProviderModelAPI          `json:"api" api:"required"`
	Capabilities ProviderModelCapabilities `json:"capabilities" api:"required"`
	Cost         ProviderModelCost         `json:"cost" api:"required"`
	Headers      map[string]string         `json:"headers" api:"required"`
	Limit        ProviderModelLimit        `json:"limit" api:"required"`
	Name         string                    `json:"name" api:"required"`
	Options      map[string]any            `json:"options" api:"required"`
	ProviderID   string                    `json:"providerID" api:"required"`
	ReleaseDate  string                    `json:"release_date" api:"required"`
	// Any of "alpha", "beta", "deprecated", "active".
	Status   string                    `json:"status" api:"required"`
	Family   string                    `json:"family"`
	Variants map[string]map[string]any `json:"variants"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID           respjson.Field
		API          respjson.Field
		Capabilities respjson.Field
		Cost         respjson.Field
		Headers      respjson.Field
		Limit        respjson.Field
		Name         respjson.Field
		Options      respjson.Field
		ProviderID   respjson.Field
		ReleaseDate  respjson.Field
		Status       respjson.Field
		Family       respjson.Field
		Variants     respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModel) RawJSON 

func (r ProviderModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModel) UnmarshalJSON 

func (r *ProviderModel) UnmarshalJSON(data []byte) error

type ProviderModelAPI 

type ProviderModelAPI struct {
	ID  string `json:"id" api:"required"`
	Npm string `json:"npm" api:"required"`
	URL string `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Npm         respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelAPI) RawJSON 

func (r ProviderModelAPI) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelAPI) UnmarshalJSON 

func (r *ProviderModelAPI) UnmarshalJSON(data []byte) error

type ProviderModelCapabilities 

type ProviderModelCapabilities struct {
	Attachment  bool                                      `json:"attachment" api:"required"`
	Input       ProviderModelCapabilitiesInput            `json:"input" api:"required"`
	Interleaved ProviderModelCapabilitiesInterleavedUnion `json:"interleaved" api:"required"`
	Output      ProviderModelCapabilitiesOutput           `json:"output" api:"required"`
	Reasoning   bool                                      `json:"reasoning" api:"required"`
	Temperature bool                                      `json:"temperature" api:"required"`
	Toolcall    bool                                      `json:"toolcall" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Attachment  respjson.Field
		Input       respjson.Field
		Interleaved respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		Temperature respjson.Field
		Toolcall    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCapabilities) RawJSON 

func (r ProviderModelCapabilities) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCapabilities) UnmarshalJSON 

func (r *ProviderModelCapabilities) UnmarshalJSON(data []byte) error

type ProviderModelCapabilitiesInput 

type ProviderModelCapabilitiesInput struct {
	Audio bool `json:"audio" api:"required"`
	Image bool `json:"image" api:"required"`
	Pdf   bool `json:"pdf" api:"required"`
	Text  bool `json:"text" api:"required"`
	Video bool `json:"video" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Audio       respjson.Field
		Image       respjson.Field
		Pdf         respjson.Field
		Text        respjson.Field
		Video       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCapabilitiesInput) RawJSON 

func (r ProviderModelCapabilitiesInput) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCapabilitiesInput) UnmarshalJSON 

func (r *ProviderModelCapabilitiesInput) UnmarshalJSON(data []byte) error

type ProviderModelCapabilitiesInterleavedField 

type ProviderModelCapabilitiesInterleavedField struct {
	// Any of "reasoning_content", "reasoning_details".
	Field string `json:"field" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Field       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCapabilitiesInterleavedField) RawJSON 

func (r ProviderModelCapabilitiesInterleavedField) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCapabilitiesInterleavedField) UnmarshalJSON 

func (r *ProviderModelCapabilitiesInterleavedField) UnmarshalJSON(data []byte) error

type ProviderModelCapabilitiesInterleavedUnion 

type ProviderModelCapabilitiesInterleavedUnion struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfBool bool `json:",inline"`
	// This field is from variant [ProviderModelCapabilitiesInterleavedField].
	Field string `json:"field"`
	JSON  struct {
		OfBool respjson.Field
		Field  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ProviderModelCapabilitiesInterleavedUnion contains all possible properties and values from [bool], ProviderModelCapabilitiesInterleavedField.

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfBool]

func (ProviderModelCapabilitiesInterleavedUnion) AsBool 

func (u ProviderModelCapabilitiesInterleavedUnion) AsBool() (v bool)

func (ProviderModelCapabilitiesInterleavedUnion) AsProviderModelCapabilitiesInterleavedField 

func (u ProviderModelCapabilitiesInterleavedUnion) AsProviderModelCapabilitiesInterleavedField() (v ProviderModelCapabilitiesInterleavedField)

func (ProviderModelCapabilitiesInterleavedUnion) RawJSON 

func (u ProviderModelCapabilitiesInterleavedUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCapabilitiesInterleavedUnion) UnmarshalJSON 

func (r *ProviderModelCapabilitiesInterleavedUnion) UnmarshalJSON(data []byte) error

type ProviderModelCapabilitiesOutput 

type ProviderModelCapabilitiesOutput struct {
	Audio bool `json:"audio" api:"required"`
	Image bool `json:"image" api:"required"`
	Pdf   bool `json:"pdf" api:"required"`
	Text  bool `json:"text" api:"required"`
	Video bool `json:"video" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Audio       respjson.Field
		Image       respjson.Field
		Pdf         respjson.Field
		Text        respjson.Field
		Video       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCapabilitiesOutput) RawJSON 

func (r ProviderModelCapabilitiesOutput) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCapabilitiesOutput) UnmarshalJSON 

func (r *ProviderModelCapabilitiesOutput) UnmarshalJSON(data []byte) error

type ProviderModelCost 

type ProviderModelCost struct {
	Cache                ProviderModelCostCache                `json:"cache" api:"required"`
	Input                float64                               `json:"input" api:"required"`
	Output               float64                               `json:"output" api:"required"`
	ExperimentalOver200K ProviderModelCostExperimentalOver200K `json:"experimentalOver200K"`
	Tiers                []ProviderModelCostTier               `json:"tiers"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache                respjson.Field
		Input                respjson.Field
		Output               respjson.Field
		ExperimentalOver200K respjson.Field
		Tiers                respjson.Field
		ExtraFields          map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCost) RawJSON 

func (r ProviderModelCost) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCost) UnmarshalJSON 

func (r *ProviderModelCost) UnmarshalJSON(data []byte) error

type ProviderModelCostCache 

type ProviderModelCostCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCostCache) RawJSON 

func (r ProviderModelCostCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCostCache) UnmarshalJSON 

func (r *ProviderModelCostCache) UnmarshalJSON(data []byte) error

type ProviderModelCostExperimentalOver200K 

type ProviderModelCostExperimentalOver200K struct {
	Cache  ProviderModelCostExperimentalOver200KCache `json:"cache" api:"required"`
	Input  float64                                    `json:"input" api:"required"`
	Output float64                                    `json:"output" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCostExperimentalOver200K) RawJSON 

func (r ProviderModelCostExperimentalOver200K) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCostExperimentalOver200K) UnmarshalJSON 

func (r *ProviderModelCostExperimentalOver200K) UnmarshalJSON(data []byte) error

type ProviderModelCostExperimentalOver200KCache 

type ProviderModelCostExperimentalOver200KCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCostExperimentalOver200KCache) RawJSON 

func (r ProviderModelCostExperimentalOver200KCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCostExperimentalOver200KCache) UnmarshalJSON 

func (r *ProviderModelCostExperimentalOver200KCache) UnmarshalJSON(data []byte) error

type ProviderModelCostTier 

type ProviderModelCostTier struct {
	Cache  ProviderModelCostTierCache `json:"cache" api:"required"`
	Input  float64                    `json:"input" api:"required"`
	Output float64                    `json:"output" api:"required"`
	Tier   ProviderModelCostTierTier  `json:"tier" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Tier        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCostTier) RawJSON 

func (r ProviderModelCostTier) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCostTier) UnmarshalJSON 

func (r *ProviderModelCostTier) UnmarshalJSON(data []byte) error

type ProviderModelCostTierCache 

type ProviderModelCostTierCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCostTierCache) RawJSON 

func (r ProviderModelCostTierCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCostTierCache) UnmarshalJSON 

func (r *ProviderModelCostTierCache) UnmarshalJSON(data []byte) error

type ProviderModelCostTierTier 

type ProviderModelCostTierTier struct {
	Size float64 `json:"size" api:"required"`
	// Any of "context".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Size        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelCostTierTier) RawJSON 

func (r ProviderModelCostTierTier) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelCostTierTier) UnmarshalJSON 

func (r *ProviderModelCostTierTier) UnmarshalJSON(data []byte) error

type ProviderModelLimit 

type ProviderModelLimit struct {
	Context float64 `json:"context" api:"required"`
	Output  float64 `json:"output" api:"required"`
	Input   float64 `json:"input"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Context     respjson.Field
		Output      respjson.Field
		Input       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderModelLimit) RawJSON 

func (r ProviderModelLimit) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderModelLimit) UnmarshalJSON 

func (r *ProviderModelLimit) UnmarshalJSON(data []byte) error

type ProviderOAuthHandleCallbackParams 

type ProviderOAuthHandleCallbackParams struct {
	// Auth method index
	Method    float64           `json:"method" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Code      param.Opt[string] `json:"code,omitzero"`
	// contains filtered or unexported fields
}

func (ProviderOAuthHandleCallbackParams) MarshalJSON 

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

func (ProviderOAuthHandleCallbackParams) URLQuery 

func (r ProviderOAuthHandleCallbackParams) URLQuery() (v url.Values, err error)

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

func (*ProviderOAuthHandleCallbackParams) UnmarshalJSON 

func (r *ProviderOAuthHandleCallbackParams) UnmarshalJSON(data []byte) error

type ProviderOAuthService 

type ProviderOAuthService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi provider routes.

ProviderOAuthService contains methods and other services that help with interacting with the opencode-stainless 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 NewProviderOAuthService method instead.

func NewProviderOAuthService 

func NewProviderOAuthService(opts ...option.RequestOption) (r ProviderOAuthService)

NewProviderOAuthService 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 (*ProviderOAuthService) HandleCallback 

func (r *ProviderOAuthService) HandleCallback(ctx context.Context, providerID string, params ProviderOAuthHandleCallbackParams, opts ...option.RequestOption) (res *bool, err error)

Handle the OAuth callback from a provider after user authorization.

func (*ProviderOAuthService) StartAuthorization 

func (r *ProviderOAuthService) StartAuthorization(ctx context.Context, providerID string, params ProviderOAuthStartAuthorizationParams, opts ...option.RequestOption) (res *ProviderOAuthStartAuthorizationResponse, err error)

Start the OAuth authorization flow for a provider.

type ProviderOAuthStartAuthorizationParams 

type ProviderOAuthStartAuthorizationParams struct {
	// Auth method index
	Method    float64           `json:"method" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Inputs    map[string]string `json:"inputs,omitzero"`
	// contains filtered or unexported fields
}

func (ProviderOAuthStartAuthorizationParams) MarshalJSON 

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

func (ProviderOAuthStartAuthorizationParams) URLQuery 

func (r ProviderOAuthStartAuthorizationParams) URLQuery() (v url.Values, err error)

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

func (*ProviderOAuthStartAuthorizationParams) UnmarshalJSON 

func (r *ProviderOAuthStartAuthorizationParams) UnmarshalJSON(data []byte) error

type ProviderOAuthStartAuthorizationResponse 

type ProviderOAuthStartAuthorizationResponse struct {
	Instructions string `json:"instructions" api:"required"`
	// Any of "auto", "code".
	Method ProviderOAuthStartAuthorizationResponseMethod `json:"method" api:"required"`
	URL    string                                        `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Instructions respjson.Field
		Method       respjson.Field
		URL          respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderOAuthStartAuthorizationResponse) RawJSON 

func (r ProviderOAuthStartAuthorizationResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderOAuthStartAuthorizationResponse) UnmarshalJSON 

func (r *ProviderOAuthStartAuthorizationResponse) UnmarshalJSON(data []byte) error

type ProviderOAuthStartAuthorizationResponseMethod 

type ProviderOAuthStartAuthorizationResponseMethod string
const (
	ProviderOAuthStartAuthorizationResponseMethodAuto ProviderOAuthStartAuthorizationResponseMethod = "auto"
	ProviderOAuthStartAuthorizationResponseMethodCode ProviderOAuthStartAuthorizationResponseMethod = "code"
)

type ProviderService 

type ProviderService struct {

	// Experimental HttpApi provider routes.
	OAuth ProviderOAuthService
	// contains filtered or unexported fields
}

Experimental HttpApi provider routes.

ProviderService contains methods and other services that help with interacting with the opencode-stainless 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 NewProviderService method instead.

func NewProviderService 

func NewProviderService(opts ...option.RequestOption) (r ProviderService)

NewProviderService 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 (*ProviderService) GetAuthMethods 

func (r *ProviderService) GetAuthMethods(ctx context.Context, query ProviderGetAuthMethodsParams, opts ...option.RequestOption) (res *ProviderGetAuthMethodsResponse, err error)

Retrieve available authentication methods for all AI providers.

func (*ProviderService) List 

func (r *ProviderService) List(ctx context.Context, query ProviderListParams, opts ...option.RequestOption) (res *ProviderListResponse, err error)

Get a list of all available AI providers, including both available and connected ones.

type ProviderSource 

type ProviderSource string
const (
	ProviderSourceEnv    ProviderSource = "env"
	ProviderSourceConfig ProviderSource = "config"
	ProviderSourceCustom ProviderSource = "custom"
	ProviderSourceAPI    ProviderSource = "api"
)

type ProviderV2Info 

type ProviderV2Info struct {
	ID       string                      `json:"id" api:"required"`
	Enabled  ProviderV2InfoEnabledUnion  `json:"enabled" api:"required"`
	Endpoint ProviderV2InfoEndpointUnion `json:"endpoint" api:"required"`
	Env      []string                    `json:"env" api:"required"`
	Name     string                      `json:"name" api:"required"`
	Options  ProviderV2InfoOptions       `json:"options" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Enabled     respjson.Field
		Endpoint    respjson.Field
		Env         respjson.Field
		Name        respjson.Field
		Options     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2Info) RawJSON 

func (r ProviderV2Info) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2Info) UnmarshalJSON 

func (r *ProviderV2Info) UnmarshalJSON(data []byte) error

type ProviderV2InfoEnabledBoolean 

type ProviderV2InfoEnabledBoolean bool
const (
	ProviderV2InfoEnabledBooleanFalse ProviderV2InfoEnabledBoolean = false
)

type ProviderV2InfoEnabledObject 

type ProviderV2InfoEnabledObject struct {
	Name string `json:"name" api:"required"`
	// Any of "env".
	Via string `json:"via" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Name        respjson.Field
		Via         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEnabledObject) RawJSON 

func (r ProviderV2InfoEnabledObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEnabledObject) UnmarshalJSON 

func (r *ProviderV2InfoEnabledObject) UnmarshalJSON(data []byte) error

type ProviderV2InfoEnabledObject2 

type ProviderV2InfoEnabledObject2 struct {
	Service string `json:"service" api:"required"`
	// Any of "auth".
	Via string `json:"via" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Service     respjson.Field
		Via         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEnabledObject2) RawJSON 

func (r ProviderV2InfoEnabledObject2) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEnabledObject2) UnmarshalJSON 

func (r *ProviderV2InfoEnabledObject2) UnmarshalJSON(data []byte) error

type ProviderV2InfoEnabledObject3 

type ProviderV2InfoEnabledObject3 struct {
	Data map[string]any `json:"data" api:"required"`
	// Any of "custom".
	Via string `json:"via" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Via         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEnabledObject3) RawJSON 

func (r ProviderV2InfoEnabledObject3) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEnabledObject3) UnmarshalJSON 

func (r *ProviderV2InfoEnabledObject3) UnmarshalJSON(data []byte) error

type ProviderV2InfoEnabledUnion 

type ProviderV2InfoEnabledUnion struct {
	// This field will be present if the value is a [bool] instead of an object.
	OfProviderV2InfoEnabledBoolean bool `json:",inline"`
	// This field is from variant [ProviderV2InfoEnabledObject].
	Name string `json:"name"`
	Via  string `json:"via"`
	// This field is from variant [ProviderV2InfoEnabledObject2].
	Service string `json:"service"`
	// This field is from variant [ProviderV2InfoEnabledObject3].
	Data map[string]any `json:"data"`
	JSON struct {
		OfProviderV2InfoEnabledBoolean respjson.Field
		Name                           respjson.Field
		Via                            respjson.Field
		Service                        respjson.Field
		Data                           respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ProviderV2InfoEnabledUnion contains all possible properties and values from [bool], ProviderV2InfoEnabledObject, ProviderV2InfoEnabledObject2, ProviderV2InfoEnabledObject3.

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfProviderV2InfoEnabledBoolean]

func (ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledBoolean 

func (u ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledBoolean() (v bool)

func (ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledObject 

func (u ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledObject() (v ProviderV2InfoEnabledObject)

func (ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledObject2 

func (u ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledObject2() (v ProviderV2InfoEnabledObject2)

func (ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledObject3 

func (u ProviderV2InfoEnabledUnion) AsProviderV2InfoEnabledObject3() (v ProviderV2InfoEnabledObject3)

func (ProviderV2InfoEnabledUnion) RawJSON 

func (u ProviderV2InfoEnabledUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEnabledUnion) UnmarshalJSON 

func (r *ProviderV2InfoEnabledUnion) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointObject 

type ProviderV2InfoEndpointObject struct {
	// Any of "openai/responses".
	Type      string `json:"type" api:"required"`
	URL       string `json:"url" api:"required"`
	Websocket bool   `json:"websocket"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Websocket   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEndpointObject) RawJSON 

func (r ProviderV2InfoEndpointObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointObject) UnmarshalJSON 

func (r *ProviderV2InfoEndpointObject) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointObject2 

type ProviderV2InfoEndpointObject2 struct {
	// Any of "openai/completions".
	Type      string                                      `json:"type" api:"required"`
	URL       string                                      `json:"url" api:"required"`
	Reasoning ProviderV2InfoEndpointObject2ReasoningUnion `json:"reasoning"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEndpointObject2) RawJSON 

func (r ProviderV2InfoEndpointObject2) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointObject2) UnmarshalJSON 

func (r *ProviderV2InfoEndpointObject2) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointObject2ReasoningType 

type ProviderV2InfoEndpointObject2ReasoningType struct {
	// Any of "reasoning_content".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEndpointObject2ReasoningType) RawJSON 

func (r ProviderV2InfoEndpointObject2ReasoningType) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointObject2ReasoningType) UnmarshalJSON 

func (r *ProviderV2InfoEndpointObject2ReasoningType) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointObject2ReasoningType2 

type ProviderV2InfoEndpointObject2ReasoningType2 struct {
	// Any of "reasoning_details".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEndpointObject2ReasoningType2) RawJSON 

func (r ProviderV2InfoEndpointObject2ReasoningType2) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointObject2ReasoningType2) UnmarshalJSON 

func (r *ProviderV2InfoEndpointObject2ReasoningType2) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointObject2ReasoningUnion 

type ProviderV2InfoEndpointObject2ReasoningUnion struct {
	Type string `json:"type"`
	JSON struct {
		Type respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ProviderV2InfoEndpointObject2ReasoningUnion contains all possible properties and values from ProviderV2InfoEndpointObject2ReasoningType, ProviderV2InfoEndpointObject2ReasoningType2.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (ProviderV2InfoEndpointObject2ReasoningUnion) AsProviderV2InfoEndpointObject2ReasoningType 

func (u ProviderV2InfoEndpointObject2ReasoningUnion) AsProviderV2InfoEndpointObject2ReasoningType() (v ProviderV2InfoEndpointObject2ReasoningType)

func (ProviderV2InfoEndpointObject2ReasoningUnion) AsProviderV2InfoEndpointObject2ReasoningType2 

func (u ProviderV2InfoEndpointObject2ReasoningUnion) AsProviderV2InfoEndpointObject2ReasoningType2() (v ProviderV2InfoEndpointObject2ReasoningType2)

func (ProviderV2InfoEndpointObject2ReasoningUnion) RawJSON 

func (u ProviderV2InfoEndpointObject2ReasoningUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointObject2ReasoningUnion) UnmarshalJSON 

func (r *ProviderV2InfoEndpointObject2ReasoningUnion) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointObject3 

type ProviderV2InfoEndpointObject3 struct {
	// Any of "anthropic/messages".
	Type string `json:"type" api:"required"`
	URL  string `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEndpointObject3) RawJSON 

func (r ProviderV2InfoEndpointObject3) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointObject3) UnmarshalJSON 

func (r *ProviderV2InfoEndpointObject3) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointObject4 

type ProviderV2InfoEndpointObject4 struct {
	Package string `json:"package" api:"required"`
	// Any of "aisdk".
	Type string `json:"type" api:"required"`
	URL  string `json:"url"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Package     respjson.Field
		Type        respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEndpointObject4) RawJSON 

func (r ProviderV2InfoEndpointObject4) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointObject4) UnmarshalJSON 

func (r *ProviderV2InfoEndpointObject4) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointType 

type ProviderV2InfoEndpointType struct {
	// Any of "unknown".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoEndpointType) RawJSON 

func (r ProviderV2InfoEndpointType) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointType) UnmarshalJSON 

func (r *ProviderV2InfoEndpointType) UnmarshalJSON(data []byte) error

type ProviderV2InfoEndpointUnion 

type ProviderV2InfoEndpointUnion struct {
	Type string `json:"type"`
	URL  string `json:"url"`
	// This field is from variant [ProviderV2InfoEndpointObject].
	Websocket bool `json:"websocket"`
	// This field is from variant [ProviderV2InfoEndpointObject2].
	Reasoning ProviderV2InfoEndpointObject2ReasoningUnion `json:"reasoning"`
	// This field is from variant [ProviderV2InfoEndpointObject4].
	Package string `json:"package"`
	JSON    struct {
		Type      respjson.Field
		URL       respjson.Field
		Websocket respjson.Field
		Reasoning respjson.Field
		Package   respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

ProviderV2InfoEndpointUnion contains all possible properties and values from ProviderV2InfoEndpointType, ProviderV2InfoEndpointObject, ProviderV2InfoEndpointObject2, ProviderV2InfoEndpointObject3, ProviderV2InfoEndpointObject4.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject 

func (u ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject() (v ProviderV2InfoEndpointObject)

func (ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject2 

func (u ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject2() (v ProviderV2InfoEndpointObject2)

func (ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject3 

func (u ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject3() (v ProviderV2InfoEndpointObject3)

func (ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject4 

func (u ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointObject4() (v ProviderV2InfoEndpointObject4)

func (ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointType 

func (u ProviderV2InfoEndpointUnion) AsProviderV2InfoEndpointType() (v ProviderV2InfoEndpointType)

func (ProviderV2InfoEndpointUnion) RawJSON 

func (u ProviderV2InfoEndpointUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoEndpointUnion) UnmarshalJSON 

func (r *ProviderV2InfoEndpointUnion) UnmarshalJSON(data []byte) error

type ProviderV2InfoOptions 

type ProviderV2InfoOptions struct {
	Aisdk   ProviderV2InfoOptionsAisdk `json:"aisdk" api:"required"`
	Body    map[string]any             `json:"body" api:"required"`
	Headers map[string]string          `json:"headers" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Aisdk       respjson.Field
		Body        respjson.Field
		Headers     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoOptions) RawJSON 

func (r ProviderV2InfoOptions) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoOptions) UnmarshalJSON 

func (r *ProviderV2InfoOptions) UnmarshalJSON(data []byte) error

type ProviderV2InfoOptionsAisdk 

type ProviderV2InfoOptionsAisdk struct {
	Provider map[string]any `json:"provider" api:"required"`
	Request  map[string]any `json:"request" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Provider    respjson.Field
		Request     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ProviderV2InfoOptionsAisdk) RawJSON 

func (r ProviderV2InfoOptionsAisdk) RawJSON() string

Returns the unmodified JSON received from the API

func (*ProviderV2InfoOptionsAisdk) UnmarshalJSON 

func (r *ProviderV2InfoOptionsAisdk) UnmarshalJSON(data []byte) error

type Pty 

type Pty struct {
	ID      string   `json:"id" api:"required"`
	Args    []string `json:"args" api:"required"`
	Command string   `json:"command" api:"required"`
	Cwd     string   `json:"cwd" api:"required"`
	Pid     int64    `json:"pid" api:"required"`
	// Any of "running", "exited".
	Status PtyStatus `json:"status" api:"required"`
	Title  string    `json:"title" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Args        respjson.Field
		Command     respjson.Field
		Cwd         respjson.Field
		Pid         respjson.Field
		Status      respjson.Field
		Title       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Pty) RawJSON 

func (r Pty) RawJSON() string

Returns the unmodified JSON received from the API

func (*Pty) UnmarshalJSON 

func (r *Pty) UnmarshalJSON(data []byte) error

type PtyConnectSessionParams 

type PtyConnectSessionParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PtyConnectSessionParams) URLQuery 

func (r PtyConnectSessionParams) URLQuery() (v url.Values, err error)

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

type PtyDeleteSessionParams 

type PtyDeleteSessionParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PtyDeleteSessionParams) URLQuery 

func (r PtyDeleteSessionParams) URLQuery() (v url.Values, err error)

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

type PtyGetSessionParams 

type PtyGetSessionParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PtyGetSessionParams) URLQuery 

func (r PtyGetSessionParams) URLQuery() (v url.Values, err error)

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

type PtyListSessionsParams 

type PtyListSessionsParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PtyListSessionsParams) URLQuery 

func (r PtyListSessionsParams) URLQuery() (v url.Values, err error)

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

type PtyListShellsParams 

type PtyListShellsParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PtyListShellsParams) URLQuery 

func (r PtyListShellsParams) URLQuery() (v url.Values, err error)

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

type PtyListShellsResponse 

type PtyListShellsResponse struct {
	Acceptable bool   `json:"acceptable" api:"required"`
	Name       string `json:"name" api:"required"`
	Path       string `json:"path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Acceptable  respjson.Field
		Name        respjson.Field
		Path        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PtyListShellsResponse) RawJSON 

func (r PtyListShellsResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*PtyListShellsResponse) UnmarshalJSON 

func (r *PtyListShellsResponse) UnmarshalJSON(data []byte) error

type PtyNewConnectTokenParams 

type PtyNewConnectTokenParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (PtyNewConnectTokenParams) URLQuery 

func (r PtyNewConnectTokenParams) URLQuery() (v url.Values, err error)

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

type PtyNewConnectTokenResponse 

type PtyNewConnectTokenResponse struct {
	ExpiresIn int64  `json:"expires_in" api:"required"`
	Ticket    string `json:"ticket" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ExpiresIn   respjson.Field
		Ticket      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

WebSocket connect token

func (PtyNewConnectTokenResponse) RawJSON 

func (r PtyNewConnectTokenResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*PtyNewConnectTokenResponse) UnmarshalJSON 

func (r *PtyNewConnectTokenResponse) UnmarshalJSON(data []byte) error

type PtyNewSessionParams 

type PtyNewSessionParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Command   param.Opt[string] `json:"command,omitzero"`
	Cwd       param.Opt[string] `json:"cwd,omitzero"`
	Title     param.Opt[string] `json:"title,omitzero"`
	Args      []string          `json:"args,omitzero"`
	Env       map[string]string `json:"env,omitzero"`
	// contains filtered or unexported fields
}

func (PtyNewSessionParams) MarshalJSON 

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

func (PtyNewSessionParams) URLQuery 

func (r PtyNewSessionParams) URLQuery() (v url.Values, err error)

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

func (*PtyNewSessionParams) UnmarshalJSON 

func (r *PtyNewSessionParams) UnmarshalJSON(data []byte) error

type PtyService 

type PtyService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi PTY routes.

PtyService contains methods and other services that help with interacting with the opencode-stainless 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 NewPtyService method instead.

func NewPtyService 

func NewPtyService(opts ...option.RequestOption) (r PtyService)

NewPtyService 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 (*PtyService) ConnectSession 

func (r *PtyService) ConnectSession(ctx context.Context, ptyID string, query PtyConnectSessionParams, opts ...option.RequestOption) (res *bool, err error)

Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.

func (*PtyService) DeleteSession 

func (r *PtyService) DeleteSession(ctx context.Context, ptyID string, body PtyDeleteSessionParams, opts ...option.RequestOption) (res *bool, err error)

Remove and terminate a specific pseudo-terminal (PTY) session.

func (*PtyService) GetSession 

func (r *PtyService) GetSession(ctx context.Context, ptyID string, query PtyGetSessionParams, opts ...option.RequestOption) (res *Pty, err error)

Retrieve detailed information about a specific pseudo-terminal (PTY) session.

func (*PtyService) ListSessions 

func (r *PtyService) ListSessions(ctx context.Context, query PtyListSessionsParams, opts ...option.RequestOption) (res *[]Pty, err error)

Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode.

func (*PtyService) ListShells 

func (r *PtyService) ListShells(ctx context.Context, query PtyListShellsParams, opts ...option.RequestOption) (res *[]PtyListShellsResponse, err error)

Get a list of available shells on the system.

func (*PtyService) NewConnectToken 

func (r *PtyService) NewConnectToken(ctx context.Context, ptyID string, body PtyNewConnectTokenParams, opts ...option.RequestOption) (res *PtyNewConnectTokenResponse, err error)

Create a short-lived ticket for opening a PTY WebSocket connection.

func (*PtyService) NewSession 

func (r *PtyService) NewSession(ctx context.Context, params PtyNewSessionParams, opts ...option.RequestOption) (res *Pty, err error)

Create a new pseudo-terminal (PTY) session for running shell commands and processes.

func (*PtyService) UpdateSession 

func (r *PtyService) UpdateSession(ctx context.Context, ptyID string, params PtyUpdateSessionParams, opts ...option.RequestOption) (res *Pty, err error)

Update properties of an existing pseudo-terminal (PTY) session.

type PtyStatus 

type PtyStatus string
const (
	PtyStatusRunning PtyStatus = "running"
	PtyStatusExited  PtyStatus = "exited"
)

type PtyUpdateSessionParams 

type PtyUpdateSessionParams struct {
	Directory param.Opt[string]          `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]          `query:"workspace,omitzero" json:"-"`
	Title     param.Opt[string]          `json:"title,omitzero"`
	Size      PtyUpdateSessionParamsSize `json:"size,omitzero"`
	// contains filtered or unexported fields
}

func (PtyUpdateSessionParams) MarshalJSON 

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

func (PtyUpdateSessionParams) URLQuery 

func (r PtyUpdateSessionParams) URLQuery() (v url.Values, err error)

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

func (*PtyUpdateSessionParams) UnmarshalJSON 

func (r *PtyUpdateSessionParams) UnmarshalJSON(data []byte) error

type PtyUpdateSessionParamsSize 

type PtyUpdateSessionParamsSize struct {
	Cols int64 `json:"cols" api:"required"`
	Rows int64 `json:"rows" api:"required"`
	// contains filtered or unexported fields
}

The properties Cols, Rows are required.

func (PtyUpdateSessionParamsSize) MarshalJSON 

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

func (*PtyUpdateSessionParamsSize) UnmarshalJSON 

func (r *PtyUpdateSessionParamsSize) UnmarshalJSON(data []byte) error

type QuestionListPendingParams 

type QuestionListPendingParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (QuestionListPendingParams) URLQuery 

func (r QuestionListPendingParams) URLQuery() (v url.Values, err error)

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

type QuestionRejectParams 

type QuestionRejectParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (QuestionRejectParams) URLQuery 

func (r QuestionRejectParams) URLQuery() (v url.Values, err error)

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

type QuestionReplyParams 

type QuestionReplyParams struct {
	// User answers in order of questions (each answer is an array of selected labels)
	Answers   [][]string        `json:"answers,omitzero" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (QuestionReplyParams) MarshalJSON 

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

func (QuestionReplyParams) URLQuery 

func (r QuestionReplyParams) URLQuery() (v url.Values, err error)

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

func (*QuestionReplyParams) UnmarshalJSON 

func (r *QuestionReplyParams) UnmarshalJSON(data []byte) error

type QuestionRequest 

type QuestionRequest struct {
	ID string `json:"id" api:"required"`
	// Questions to ask
	Questions []QuestionRequestQuestion `json:"questions" api:"required"`
	SessionID string                    `json:"sessionID" api:"required"`
	Tool      QuestionRequestTool       `json:"tool"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Questions   respjson.Field
		SessionID   respjson.Field
		Tool        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (QuestionRequest) RawJSON 

func (r QuestionRequest) RawJSON() string

Returns the unmodified JSON received from the API

func (*QuestionRequest) UnmarshalJSON 

func (r *QuestionRequest) UnmarshalJSON(data []byte) error

type QuestionRequestQuestion 

type QuestionRequestQuestion struct {
	// Very short label (max 30 chars)
	Header string `json:"header" api:"required"`
	// Available choices
	Options []QuestionRequestQuestionOption `json:"options" api:"required"`
	// Complete question
	Question string `json:"question" api:"required"`
	Custom   bool   `json:"custom"`
	Multiple bool   `json:"multiple"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Header      respjson.Field
		Options     respjson.Field
		Question    respjson.Field
		Custom      respjson.Field
		Multiple    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (QuestionRequestQuestion) RawJSON 

func (r QuestionRequestQuestion) RawJSON() string

Returns the unmodified JSON received from the API

func (*QuestionRequestQuestion) UnmarshalJSON 

func (r *QuestionRequestQuestion) UnmarshalJSON(data []byte) error

type QuestionRequestQuestionOption 

type QuestionRequestQuestionOption struct {
	// Explanation of choice
	Description string `json:"description" api:"required"`
	// Display text (1-5 words, concise)
	Label string `json:"label" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Description respjson.Field
		Label       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (QuestionRequestQuestionOption) RawJSON 

func (r QuestionRequestQuestionOption) RawJSON() string

Returns the unmodified JSON received from the API

func (*QuestionRequestQuestionOption) UnmarshalJSON 

func (r *QuestionRequestQuestionOption) UnmarshalJSON(data []byte) error

type QuestionRequestTool 

type QuestionRequestTool struct {
	CallID    string `json:"callID" api:"required"`
	MessageID string `json:"messageID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CallID      respjson.Field
		MessageID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (QuestionRequestTool) RawJSON 

func (r QuestionRequestTool) RawJSON() string

Returns the unmodified JSON received from the API

func (*QuestionRequestTool) UnmarshalJSON 

func (r *QuestionRequestTool) UnmarshalJSON(data []byte) error

type QuestionService 

type QuestionService struct {
	// contains filtered or unexported fields
}

Question routes.

QuestionService contains methods and other services that help with interacting with the opencode-stainless 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 NewQuestionService method instead.

func NewQuestionService 

func NewQuestionService(opts ...option.RequestOption) (r QuestionService)

NewQuestionService 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 (*QuestionService) ListPending 

func (r *QuestionService) ListPending(ctx context.Context, query QuestionListPendingParams, opts ...option.RequestOption) (res *[]QuestionRequest, err error)

Get all pending question requests across all sessions.

func (*QuestionService) Reject 

func (r *QuestionService) Reject(ctx context.Context, requestID string, body QuestionRejectParams, opts ...option.RequestOption) (res *bool, err error)

Reject a question request from the AI assistant.

func (*QuestionService) Reply 

func (r *QuestionService) Reply(ctx context.Context, requestID string, params QuestionReplyParams, opts ...option.RequestOption) (res *bool, err error)

Provide answers to a question request from the AI assistant.

type Range 

type Range struct {
	End   RangeEnd   `json:"end" api:"required"`
	Start RangeStart `json:"start" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Start       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Range) RawJSON 

func (r Range) RawJSON() string

Returns the unmodified JSON received from the API

func (Range) ToParam 

func (r Range) ToParam() RangeParam

ToParam converts this Range to a RangeParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with RangeParam.Overrides()

func (*Range) UnmarshalJSON 

func (r *Range) UnmarshalJSON(data []byte) error

type RangeEnd 

type RangeEnd struct {
	Character int64 `json:"character" api:"required"`
	Line      int64 `json:"line" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Character   respjson.Field
		Line        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (RangeEnd) RawJSON 

func (r RangeEnd) RawJSON() string

Returns the unmodified JSON received from the API

func (*RangeEnd) UnmarshalJSON 

func (r *RangeEnd) UnmarshalJSON(data []byte) error

type RangeEndParam 

type RangeEndParam struct {
	Character int64 `json:"character" api:"required"`
	Line      int64 `json:"line" api:"required"`
	// contains filtered or unexported fields
}

The properties Character, Line are required.

func (RangeEndParam) MarshalJSON 

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

func (*RangeEndParam) UnmarshalJSON 

func (r *RangeEndParam) UnmarshalJSON(data []byte) error

type RangeParam 

type RangeParam struct {
	End   RangeEndParam   `json:"end,omitzero" api:"required"`
	Start RangeStartParam `json:"start,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties End, Start are required.

func (RangeParam) MarshalJSON 

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

func (*RangeParam) UnmarshalJSON 

func (r *RangeParam) UnmarshalJSON(data []byte) error

type RangeStart 

type RangeStart struct {
	Character int64 `json:"character" api:"required"`
	Line      int64 `json:"line" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Character   respjson.Field
		Line        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (RangeStart) RawJSON 

func (r RangeStart) RawJSON() string

Returns the unmodified JSON received from the API

func (*RangeStart) UnmarshalJSON 

func (r *RangeStart) UnmarshalJSON(data []byte) error

type RangeStartParam 

type RangeStartParam struct {
	Character int64 `json:"character" api:"required"`
	Line      int64 `json:"line" api:"required"`
	// contains filtered or unexported fields
}

The properties Character, Line are required.

func (RangeStartParam) MarshalJSON 

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

func (*RangeStartParam) UnmarshalJSON 

func (r *RangeStartParam) UnmarshalJSON(data []byte) error

type Session 

type Session struct {
	ID          string           `json:"id" api:"required"`
	Directory   string           `json:"directory" api:"required"`
	ProjectID   string           `json:"projectID" api:"required"`
	Slug        string           `json:"slug" api:"required"`
	Time        SessionTime      `json:"time" api:"required"`
	Title       string           `json:"title" api:"required"`
	Version     string           `json:"version" api:"required"`
	Agent       string           `json:"agent"`
	Cost        float64          `json:"cost"`
	Model       SessionModel     `json:"model"`
	ParentID    string           `json:"parentID"`
	Path        string           `json:"path"`
	Permission  []PermissionRule `json:"permission"`
	Revert      SessionRevert    `json:"revert"`
	Share       SessionShare     `json:"share"`
	Summary     SessionSummary   `json:"summary"`
	Tokens      SessionTokens    `json:"tokens"`
	WorkspaceID string           `json:"workspaceID"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Directory   respjson.Field
		ProjectID   respjson.Field
		Slug        respjson.Field
		Time        respjson.Field
		Title       respjson.Field
		Version     respjson.Field
		Agent       respjson.Field
		Cost        respjson.Field
		Model       respjson.Field
		ParentID    respjson.Field
		Path        respjson.Field
		Permission  respjson.Field
		Revert      respjson.Field
		Share       respjson.Field
		Summary     respjson.Field
		Tokens      respjson.Field
		WorkspaceID respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Session) RawJSON 

func (r Session) RawJSON() string

Returns the unmodified JSON received from the API

func (*Session) UnmarshalJSON 

func (r *Session) UnmarshalJSON(data []byte) error

type SessionAbortParams 

type SessionAbortParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionAbortParams) URLQuery 

func (r SessionAbortParams) URLQuery() (v url.Values, err error)

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

type SessionDeleteParams 

type SessionDeleteParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionDeleteParams) URLQuery 

func (r SessionDeleteParams) URLQuery() (v url.Values, err error)

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

type SessionErrorUnknown 

type SessionErrorUnknown struct {
	Message string `json:"message" api:"required"`
	// Any of "unknown".
	Type SessionErrorUnknownType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionErrorUnknown) RawJSON 

func (r SessionErrorUnknown) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionErrorUnknown) UnmarshalJSON 

func (r *SessionErrorUnknown) UnmarshalJSON(data []byte) error

type SessionErrorUnknownType 

type SessionErrorUnknownType string
const (
	SessionErrorUnknownTypeUnknown SessionErrorUnknownType = "unknown"
)

type SessionForkParams 

type SessionForkParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	MessageID param.Opt[string] `json:"messageID,omitzero"`
	// contains filtered or unexported fields
}

func (SessionForkParams) MarshalJSON 

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

func (SessionForkParams) URLQuery 

func (r SessionForkParams) URLQuery() (v url.Values, err error)

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

func (*SessionForkParams) UnmarshalJSON 

func (r *SessionForkParams) UnmarshalJSON(data []byte) error

type SessionGetChildrenParams 

type SessionGetChildrenParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionGetChildrenParams) URLQuery 

func (r SessionGetChildrenParams) URLQuery() (v url.Values, err error)

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

type SessionGetDiffParams 

type SessionGetDiffParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	MessageID param.Opt[string] `query:"messageID,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionGetDiffParams) URLQuery 

func (r SessionGetDiffParams) URLQuery() (v url.Values, err error)

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

type SessionGetParams 

type SessionGetParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionGetParams) URLQuery 

func (r SessionGetParams) URLQuery() (v url.Values, err error)

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

type SessionGetStatusParams 

type SessionGetStatusParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionGetStatusParams) URLQuery 

func (r SessionGetStatusParams) URLQuery() (v url.Values, err error)

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

type SessionGetStatusResponse 

type SessionGetStatusResponse map[string]SessionGetStatusResponseItemUnion

type SessionGetStatusResponseItemObject 

type SessionGetStatusResponseItemObject struct {
	Attempt int64  `json:"attempt" api:"required"`
	Message string `json:"message" api:"required"`
	Next    int64  `json:"next" api:"required"`
	// Any of "retry".
	Type   string                                   `json:"type" api:"required"`
	Action SessionGetStatusResponseItemObjectAction `json:"action"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Attempt     respjson.Field
		Message     respjson.Field
		Next        respjson.Field
		Type        respjson.Field
		Action      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionGetStatusResponseItemObject) RawJSON 

func (r SessionGetStatusResponseItemObject) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionGetStatusResponseItemObject) UnmarshalJSON 

func (r *SessionGetStatusResponseItemObject) UnmarshalJSON(data []byte) error

type SessionGetStatusResponseItemObjectAction 

type SessionGetStatusResponseItemObjectAction struct {
	Label    string `json:"label" api:"required"`
	Message  string `json:"message" api:"required"`
	Provider string `json:"provider" api:"required"`
	Reason   string `json:"reason" api:"required"`
	Title    string `json:"title" api:"required"`
	Link     string `json:"link"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Label       respjson.Field
		Message     respjson.Field
		Provider    respjson.Field
		Reason      respjson.Field
		Title       respjson.Field
		Link        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionGetStatusResponseItemObjectAction) RawJSON 

func (r SessionGetStatusResponseItemObjectAction) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionGetStatusResponseItemObjectAction) UnmarshalJSON 

func (r *SessionGetStatusResponseItemObjectAction) UnmarshalJSON(data []byte) error

type SessionGetStatusResponseItemType 

type SessionGetStatusResponseItemType struct {
	// Any of "idle".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionGetStatusResponseItemType) RawJSON 

func (r SessionGetStatusResponseItemType) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionGetStatusResponseItemType) UnmarshalJSON 

func (r *SessionGetStatusResponseItemType) UnmarshalJSON(data []byte) error

type SessionGetStatusResponseItemType2 

type SessionGetStatusResponseItemType2 struct {
	// Any of "busy".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionGetStatusResponseItemType2) RawJSON 

func (r SessionGetStatusResponseItemType2) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionGetStatusResponseItemType2) UnmarshalJSON 

func (r *SessionGetStatusResponseItemType2) UnmarshalJSON(data []byte) error

type SessionGetStatusResponseItemUnion 

type SessionGetStatusResponseItemUnion struct {
	Type string `json:"type"`
	// This field is from variant [SessionGetStatusResponseItemObject].
	Attempt int64 `json:"attempt"`
	// This field is from variant [SessionGetStatusResponseItemObject].
	Message string `json:"message"`
	// This field is from variant [SessionGetStatusResponseItemObject].
	Next int64 `json:"next"`
	// This field is from variant [SessionGetStatusResponseItemObject].
	Action SessionGetStatusResponseItemObjectAction `json:"action"`
	JSON   struct {
		Type    respjson.Field
		Attempt respjson.Field
		Message respjson.Field
		Next    respjson.Field
		Action  respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionGetStatusResponseItemUnion contains all possible properties and values from SessionGetStatusResponseItemType, SessionGetStatusResponseItemObject, SessionGetStatusResponseItemType2.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (SessionGetStatusResponseItemUnion) AsSessionGetStatusResponseItemObject 

func (u SessionGetStatusResponseItemUnion) AsSessionGetStatusResponseItemObject() (v SessionGetStatusResponseItemObject)

func (SessionGetStatusResponseItemUnion) AsSessionGetStatusResponseItemType 

func (u SessionGetStatusResponseItemUnion) AsSessionGetStatusResponseItemType() (v SessionGetStatusResponseItemType)

func (SessionGetStatusResponseItemUnion) AsSessionGetStatusResponseItemType2 

func (u SessionGetStatusResponseItemUnion) AsSessionGetStatusResponseItemType2() (v SessionGetStatusResponseItemType2)

func (SessionGetStatusResponseItemUnion) RawJSON 

func (u SessionGetStatusResponseItemUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionGetStatusResponseItemUnion) UnmarshalJSON 

func (r *SessionGetStatusResponseItemUnion) UnmarshalJSON(data []byte) error

type SessionGetTodoParams 

type SessionGetTodoParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionGetTodoParams) URLQuery 

func (r SessionGetTodoParams) URLQuery() (v url.Values, err error)

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

type SessionInitializeParams 

type SessionInitializeParams struct {
	MessageID  string            `json:"messageID" api:"required"`
	ModelID    string            `json:"modelID" api:"required"`
	ProviderID string            `json:"providerID" api:"required"`
	Directory  param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace  param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionInitializeParams) MarshalJSON 

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

func (SessionInitializeParams) URLQuery 

func (r SessionInitializeParams) URLQuery() (v url.Values, err error)

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

func (*SessionInitializeParams) UnmarshalJSON 

func (r *SessionInitializeParams) UnmarshalJSON(data []byte) error

type SessionListParams 

type SessionListParams struct {
	Directory param.Opt[string]           `query:"directory,omitzero" json:"-"`
	Limit     param.Opt[float64]          `query:"limit,omitzero" json:"-"`
	Path      param.Opt[string]           `query:"path,omitzero" json:"-"`
	Search    param.Opt[string]           `query:"search,omitzero" json:"-"`
	Start     param.Opt[float64]          `query:"start,omitzero" json:"-"`
	Workspace param.Opt[string]           `query:"workspace,omitzero" json:"-"`
	Roots     SessionListParamsRootsUnion `query:"roots,omitzero" json:"-"`
	// Any of "project".
	Scope SessionListParamsScope `query:"scope,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionListParams) URLQuery 

func (r SessionListParams) URLQuery() (v url.Values, err error)

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

type SessionListParamsRootsString 

type SessionListParamsRootsString string
const (
	SessionListParamsRootsStringTrue  SessionListParamsRootsString = "true"
	SessionListParamsRootsStringFalse SessionListParamsRootsString = "false"
)

type SessionListParamsRootsUnion 

type SessionListParamsRootsUnion struct {
	OfBool param.Opt[bool] `query:",omitzero,inline"`
	// Check if union is this variant with
	// !param.IsOmitted(union.OfSessionListsRootsString)
	OfSessionListsRootsString param.Opt[string] `query:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

type SessionListParamsScope 

type SessionListParamsScope string
const (
	SessionListParamsScopeProject SessionListParamsScope = "project"
)

type SessionMessageDeleteParams 

type SessionMessageDeleteParams struct {
	SessionID string            `path:"sessionID" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionMessageDeleteParams) URLQuery 

func (r SessionMessageDeleteParams) URLQuery() (v url.Values, err error)

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

type SessionMessageGetParams 

type SessionMessageGetParams struct {
	SessionID string            `path:"sessionID" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionMessageGetParams) URLQuery 

func (r SessionMessageGetParams) URLQuery() (v url.Values, err error)

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

type SessionMessageGetResponse 

type SessionMessageGetResponse struct {
	Info  MessageUnion `json:"info" api:"required"`
	Parts []PartUnion  `json:"parts" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		Parts       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Message

func (SessionMessageGetResponse) RawJSON 

func (r SessionMessageGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageGetResponse) UnmarshalJSON 

func (r *SessionMessageGetResponse) UnmarshalJSON(data []byte) error

type SessionMessageListParams 

type SessionMessageListParams struct {
	Before    param.Opt[string] `query:"before,omitzero" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Limit     param.Opt[int64]  `query:"limit,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionMessageListParams) URLQuery 

func (r SessionMessageListParams) URLQuery() (v url.Values, err error)

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

type SessionMessageListResponse 

type SessionMessageListResponse struct {
	Info  MessageUnion `json:"info" api:"required"`
	Parts []PartUnion  `json:"parts" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		Parts       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageListResponse) RawJSON 

func (r SessionMessageListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageListResponse) UnmarshalJSON 

func (r *SessionMessageListResponse) UnmarshalJSON(data []byte) error

type SessionMessagePartDeleteParams 

type SessionMessagePartDeleteParams struct {
	SessionID string            `path:"sessionID" api:"required" json:"-"`
	MessageID string            `path:"messageID" api:"required" json:"-"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionMessagePartDeleteParams) URLQuery 

func (r SessionMessagePartDeleteParams) URLQuery() (v url.Values, err error)

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

type SessionMessagePartService 

type SessionMessagePartService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi session routes.

SessionMessagePartService contains methods and other services that help with interacting with the opencode-stainless 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 NewSessionMessagePartService method instead.

func NewSessionMessagePartService 

func NewSessionMessagePartService(opts ...option.RequestOption) (r SessionMessagePartService)

NewSessionMessagePartService 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 (*SessionMessagePartService) Delete 

func (r *SessionMessagePartService) Delete(ctx context.Context, partID string, params SessionMessagePartDeleteParams, opts ...option.RequestOption) (res *bool, err error)

Delete a part from a message.

func (*SessionMessagePartService) Update 

func (r *SessionMessagePartService) Update(ctx context.Context, partID string, params SessionMessagePartUpdateParams, opts ...option.RequestOption) (res *PartUnion, err error)

Update a part in a message.

type SessionMessagePartUpdateParams 

type SessionMessagePartUpdateParams struct {
	PathSessionID string            `path:"sessionID" api:"required" json:"-"`
	PathMessageID string            `path:"messageID" api:"required" json:"-"`
	Directory     param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace     param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Part          PartUnionParam
	// contains filtered or unexported fields
}

func (SessionMessagePartUpdateParams) MarshalJSON 

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

func (SessionMessagePartUpdateParams) URLQuery 

func (r SessionMessagePartUpdateParams) URLQuery() (v url.Values, err error)

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

func (*SessionMessagePartUpdateParams) UnmarshalJSON 

func (r *SessionMessagePartUpdateParams) UnmarshalJSON(data []byte) error

type SessionMessageSendParams 

type SessionMessageSendParams struct {
	Parts     []SessionMessageSendParamsPartUnion `json:"parts,omitzero" api:"required"`
	Directory param.Opt[string]                   `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]                   `query:"workspace,omitzero" json:"-"`
	Agent     param.Opt[string]                   `json:"agent,omitzero"`
	MessageID param.Opt[string]                   `json:"messageID,omitzero"`
	NoReply   param.Opt[bool]                     `json:"noReply,omitzero"`
	System    param.Opt[string]                   `json:"system,omitzero"`
	Variant   param.Opt[string]                   `json:"variant,omitzero"`
	Format    OutputFormatUnionParam              `json:"format,omitzero"`
	Model     SessionMessageSendParamsModel       `json:"model,omitzero"`
	Tools     map[string]bool                     `json:"tools,omitzero"`
	// contains filtered or unexported fields
}

func (SessionMessageSendParams) MarshalJSON 

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

func (SessionMessageSendParams) URLQuery 

func (r SessionMessageSendParams) URLQuery() (v url.Values, err error)

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

func (*SessionMessageSendParams) UnmarshalJSON 

func (r *SessionMessageSendParams) UnmarshalJSON(data []byte) error

type SessionMessageSendParamsModel 

type SessionMessageSendParamsModel struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// contains filtered or unexported fields
}

The properties ModelID, ProviderID are required.

func (SessionMessageSendParamsModel) MarshalJSON 

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

func (*SessionMessageSendParamsModel) UnmarshalJSON 

func (r *SessionMessageSendParamsModel) UnmarshalJSON(data []byte) error

type SessionMessageSendParamsPartUnion 

type SessionMessageSendParamsPartUnion struct {
	OfTextPartInput    *TextPartInputParam    `json:",omitzero,inline"`
	OfFilePartInput    *FilePartInputParam    `json:",omitzero,inline"`
	OfAgentPartInput   *AgentPartInputParam   `json:",omitzero,inline"`
	OfSubtaskPartInput *SubtaskPartInputParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (SessionMessageSendParamsPartUnion) MarshalJSON 

func (u SessionMessageSendParamsPartUnion) MarshalJSON() ([]byte, error)

func (*SessionMessageSendParamsPartUnion) UnmarshalJSON 

func (u *SessionMessageSendParamsPartUnion) UnmarshalJSON(data []byte) error

type SessionMessageSendResponse 

type SessionMessageSendResponse struct {
	Info  AssistantMessage `json:"info" api:"required"`
	Parts []PartUnion      `json:"parts" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		Parts       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSendResponse) RawJSON 

func (r SessionMessageSendResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSendResponse) UnmarshalJSON 

func (r *SessionMessageSendResponse) UnmarshalJSON(data []byte) error

type SessionMessageService 

type SessionMessageService struct {

	// Experimental HttpApi session routes.
	Part SessionMessagePartService
	// contains filtered or unexported fields
}

Experimental HttpApi session routes.

SessionMessageService contains methods and other services that help with interacting with the opencode-stainless 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 NewSessionMessageService method instead.

func NewSessionMessageService 

func NewSessionMessageService(opts ...option.RequestOption) (r SessionMessageService)

NewSessionMessageService 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 (*SessionMessageService) Delete 

func (r *SessionMessageService) Delete(ctx context.Context, messageID string, params SessionMessageDeleteParams, opts ...option.RequestOption) (res *bool, err error)

Permanently delete a specific message and all of its parts from a session without reverting file changes.

func (*SessionMessageService) Get 

func (r *SessionMessageService) Get(ctx context.Context, messageID string, params SessionMessageGetParams, opts ...option.RequestOption) (res *SessionMessageGetResponse, err error)

Retrieve a specific message from a session by its message ID.

func (*SessionMessageService) List 

func (r *SessionMessageService) List(ctx context.Context, sessionID string, query SessionMessageListParams, opts ...option.RequestOption) (res *[]SessionMessageListResponse, err error)

Retrieve all messages in a session, including user prompts and AI responses.

func (*SessionMessageService) Send 

func (r *SessionMessageService) Send(ctx context.Context, sessionID string, params SessionMessageSendParams, opts ...option.RequestOption) (res *SessionMessageSendResponse, err error)

Create and send a new message to a session, streaming the AI response.

type SessionMessageSessionMessageAgentSwitched 

type SessionMessageSessionMessageAgentSwitched struct {
	ID    string                                        `json:"id" api:"required"`
	Agent string                                        `json:"agent" api:"required"`
	Time  SessionMessageSessionMessageAgentSwitchedTime `json:"time" api:"required"`
	// Any of "agent-switched".
	Type     string         `json:"type" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Agent       respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAgentSwitched) RawJSON 

func (r SessionMessageSessionMessageAgentSwitched) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAgentSwitched) UnmarshalJSON 

func (r *SessionMessageSessionMessageAgentSwitched) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAgentSwitchedTime 

type SessionMessageSessionMessageAgentSwitchedTime struct {
	Created float64 `json:"created" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAgentSwitchedTime) RawJSON 

func (r SessionMessageSessionMessageAgentSwitchedTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAgentSwitchedTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageAgentSwitchedTime) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistant 

type SessionMessageSessionMessageAssistant struct {
	ID      string                                              `json:"id" api:"required"`
	Agent   string                                              `json:"agent" api:"required"`
	Content []SessionMessageSessionMessageAssistantContentUnion `json:"content" api:"required"`
	Model   SessionMessageSessionMessageAssistantModel          `json:"model" api:"required"`
	Time    SessionMessageSessionMessageAssistantTime           `json:"time" api:"required"`
	// Any of "assistant".
	Type     string                                        `json:"type" api:"required"`
	Cost     float64                                       `json:"cost"`
	Error    SessionErrorUnknown                           `json:"error"`
	Finish   string                                        `json:"finish"`
	Metadata map[string]any                                `json:"metadata"`
	Snapshot SessionMessageSessionMessageAssistantSnapshot `json:"snapshot"`
	Tokens   SessionMessageSessionMessageAssistantTokens   `json:"tokens"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Agent       respjson.Field
		Content     respjson.Field
		Model       respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Cost        respjson.Field
		Error       respjson.Field
		Finish      respjson.Field
		Metadata    respjson.Field
		Snapshot    respjson.Field
		Tokens      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistant) RawJSON 

func (r SessionMessageSessionMessageAssistant) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistant) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistant) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning struct {
	ID   string `json:"id" api:"required"`
	Text string `json:"text" api:"required"`
	// Any of "reasoning".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantText 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantText struct {
	Text string `json:"text" api:"required"`
	// Any of "text".
	Type string `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantText) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantText) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantText) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantText) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool struct {
	ID    string                                                                            `json:"id" api:"required"`
	Name  string                                                                            `json:"name" api:"required"`
	State SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion `json:"state" api:"required"`
	Time  SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime       `json:"time" api:"required"`
	// Any of "tool".
	Type     string                                                                          `json:"type" api:"required"`
	Provider SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider `json:"provider"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Name        respjson.Field
		State       respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Provider    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider struct {
	Executed bool           `json:"executed" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Executed    respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted struct {
	Content []SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion `json:"content" api:"required"`
	Input   map[string]any                                                                                                             `json:"input" api:"required"`
	// Any of "completed".
	Status      string                 `json:"status" api:"required"`
	Structured  map[string]any         `json:"structured" api:"required"`
	Attachments []PromptFileAttachment `json:"attachments"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		Input       respjson.Field
		Status      respjson.Field
		Structured  respjson.Field
		Attachments respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion struct {
	// This field is from variant [ToolTextContent].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [ToolFileContent].
	Mime string `json:"mime"`
	// This field is from variant [ToolFileContent].
	Uri string `json:"uri"`
	// This field is from variant [ToolFileContent].
	Name string `json:"name"`
	JSON struct {
		Text respjson.Field
		Type respjson.Field
		Mime respjson.Field
		Uri  respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion contains all possible properties and values from ToolTextContent, ToolFileContent.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) AsToolFileContent 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) AsToolFileContent() (v ToolFileContent)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) AsToolTextContent 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) AsToolTextContent() (v ToolTextContent)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) RawJSON 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError struct {
	Content []SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion `json:"content" api:"required"`
	Error   SessionErrorUnknown                                                                                                    `json:"error" api:"required"`
	Input   map[string]any                                                                                                         `json:"input" api:"required"`
	// Any of "error".
	Status     string         `json:"status" api:"required"`
	Structured map[string]any `json:"structured" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		Error       respjson.Field
		Input       respjson.Field
		Status      respjson.Field
		Structured  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion struct {
	// This field is from variant [ToolTextContent].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [ToolFileContent].
	Mime string `json:"mime"`
	// This field is from variant [ToolFileContent].
	Uri string `json:"uri"`
	// This field is from variant [ToolFileContent].
	Name string `json:"name"`
	JSON struct {
		Text respjson.Field
		Type respjson.Field
		Mime respjson.Field
		Uri  respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion contains all possible properties and values from ToolTextContent, ToolFileContent.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) AsToolFileContent 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) AsToolFileContent() (v ToolFileContent)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) AsToolTextContent 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) AsToolTextContent() (v ToolTextContent)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) RawJSON 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending struct {
	Input string `json:"input" api:"required"`
	// Any of "pending".
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Input       respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning struct {
	Content []SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion `json:"content" api:"required"`
	Input   map[string]any                                                                                                           `json:"input" api:"required"`
	// Any of "running".
	Status     string         `json:"status" api:"required"`
	Structured map[string]any `json:"structured" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		Input       respjson.Field
		Status      respjson.Field
		Structured  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion struct {
	// This field is from variant [ToolTextContent].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [ToolFileContent].
	Mime string `json:"mime"`
	// This field is from variant [ToolFileContent].
	Uri string `json:"uri"`
	// This field is from variant [ToolFileContent].
	Name string `json:"name"`
	JSON struct {
		Text respjson.Field
		Type respjson.Field
		Mime respjson.Field
		Uri  respjson.Field
		Name respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion contains all possible properties and values from ToolTextContent, ToolFileContent.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) AsToolFileContent 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) AsToolFileContent() (v ToolFileContent)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) AsToolTextContent 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) AsToolTextContent() (v ToolTextContent)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) RawJSON 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion struct {
	// This field is a union of [string], [map[string]any], [map[string]any],
	// [map[string]any]
	Input  SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionInput `json:"input"`
	Status string                                                                                 `json:"status"`
	// This field is a union of
	// [[]SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion],
	// [[]SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion],
	// [[]SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion]
	Content    SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionContent `json:"content"`
	Structured any                                                                                      `json:"structured"`
	// This field is from variant
	// [SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted].
	Attachments []PromptFileAttachment `json:"attachments"`
	// This field is from variant
	// [SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError].
	Error SessionErrorUnknown `json:"error"`
	JSON  struct {
		Input       respjson.Field
		Status      respjson.Field
		Content     respjson.Field
		Structured  respjson.Field
		Attachments respjson.Field
		Error       respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion contains all possible properties and values from SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending, SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning, SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted, SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted() (v SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompleted)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError() (v SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateError)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending() (v SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStatePending)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning() (v SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunning)

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) RawJSON 

func (u SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionContent 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionContent struct {
	// This field will be present if the value is a
	// [[]SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion]
	// instead of an object.
	OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentArray []SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentUnion `json:",inline"`
	// This field will be present if the value is a
	// [[]SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion]
	// instead of an object.
	OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentArray []SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentUnion `json:",inline"`
	// This field will be present if the value is a
	// [[]SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion]
	// instead of an object.
	OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentArray []SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentUnion `json:",inline"`
	JSON                                                                                                                   struct {
		OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentArray   respjson.Field
		OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentArray respjson.Field
		OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentArray     respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionContent is an implicit subunion of SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion. SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionContent provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateRunningContentArray OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateCompletedContentArray OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorContentArray]

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionContent) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionContent) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionInput 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionInput struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field will be present if the value is a [any] instead of an object.
	OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorInput any `json:",inline"`
	JSON                                                                                                            struct {
		OfString                                                                                                        respjson.Field
		OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorInput respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionInput is an implicit subunion of SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion. SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionInput provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion.

If the underlying value is not a json object, one of the following properties will be valid: OfString OfSessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateSessionMessageToolStateErrorInput]

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionInput) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnionInput) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime 

type SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime struct {
	Created   float64 `json:"created" api:"required"`
	Completed float64 `json:"completed"`
	Pruned    float64 `json:"pruned"`
	Ran       float64 `json:"ran"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Completed   respjson.Field
		Pruned      respjson.Field
		Ran         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime) RawJSON 

func (r SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantContentUnion 

type SessionMessageSessionMessageAssistantContentUnion struct {
	Text string `json:"text"`
	Type string `json:"type"`
	ID   string `json:"id"`
	// This field is from variant
	// [SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool].
	Name string `json:"name"`
	// This field is from variant
	// [SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool].
	State SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolStateUnion `json:"state"`
	// This field is from variant
	// [SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool].
	Time SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolTime `json:"time"`
	// This field is from variant
	// [SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool].
	Provider SessionMessageSessionMessageAssistantContentSessionMessageAssistantToolProvider `json:"provider"`
	JSON     struct {
		Text     respjson.Field
		Type     respjson.Field
		ID       respjson.Field
		Name     respjson.Field
		State    respjson.Field
		Time     respjson.Field
		Provider respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageSessionMessageAssistantContentUnion contains all possible properties and values from SessionMessageSessionMessageAssistantContentSessionMessageAssistantText, SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning, SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (SessionMessageSessionMessageAssistantContentUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning 

func (u SessionMessageSessionMessageAssistantContentUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning() (v SessionMessageSessionMessageAssistantContentSessionMessageAssistantReasoning)

func (SessionMessageSessionMessageAssistantContentUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantText 

func (u SessionMessageSessionMessageAssistantContentUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantText() (v SessionMessageSessionMessageAssistantContentSessionMessageAssistantText)

func (SessionMessageSessionMessageAssistantContentUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantTool 

func (u SessionMessageSessionMessageAssistantContentUnion) AsSessionMessageSessionMessageAssistantContentSessionMessageAssistantTool() (v SessionMessageSessionMessageAssistantContentSessionMessageAssistantTool)

func (SessionMessageSessionMessageAssistantContentUnion) RawJSON 

func (u SessionMessageSessionMessageAssistantContentUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantContentUnion) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantContentUnion) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantModel 

type SessionMessageSessionMessageAssistantModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantModel) RawJSON 

func (r SessionMessageSessionMessageAssistantModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantModel) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantModel) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantSnapshot 

type SessionMessageSessionMessageAssistantSnapshot struct {
	End   string `json:"end"`
	Start string `json:"start"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		End         respjson.Field
		Start       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantSnapshot) RawJSON 

func (r SessionMessageSessionMessageAssistantSnapshot) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantSnapshot) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantSnapshot) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantTime 

type SessionMessageSessionMessageAssistantTime struct {
	Created   float64 `json:"created" api:"required"`
	Completed float64 `json:"completed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Completed   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantTime) RawJSON 

func (r SessionMessageSessionMessageAssistantTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantTime) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantTokens 

type SessionMessageSessionMessageAssistantTokens struct {
	Cache     SessionMessageSessionMessageAssistantTokensCache `json:"cache" api:"required"`
	Input     float64                                          `json:"input" api:"required"`
	Output    float64                                          `json:"output" api:"required"`
	Reasoning float64                                          `json:"reasoning" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantTokens) RawJSON 

func (r SessionMessageSessionMessageAssistantTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantTokens) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantTokens) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageAssistantTokensCache 

type SessionMessageSessionMessageAssistantTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageAssistantTokensCache) RawJSON 

func (r SessionMessageSessionMessageAssistantTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageAssistantTokensCache) UnmarshalJSON 

func (r *SessionMessageSessionMessageAssistantTokensCache) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageCompaction 

type SessionMessageSessionMessageCompaction struct {
	ID string `json:"id" api:"required"`
	// Any of "auto", "manual".
	Reason  string                                     `json:"reason" api:"required"`
	Summary string                                     `json:"summary" api:"required"`
	Time    SessionMessageSessionMessageCompactionTime `json:"time" api:"required"`
	// Any of "compaction".
	Type     string         `json:"type" api:"required"`
	Include  string         `json:"include"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Reason      respjson.Field
		Summary     respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Include     respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageCompaction) RawJSON 

func (r SessionMessageSessionMessageCompaction) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageCompaction) UnmarshalJSON 

func (r *SessionMessageSessionMessageCompaction) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageCompactionTime 

type SessionMessageSessionMessageCompactionTime struct {
	Created float64 `json:"created" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageCompactionTime) RawJSON 

func (r SessionMessageSessionMessageCompactionTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageCompactionTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageCompactionTime) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageModelSwitched 

type SessionMessageSessionMessageModelSwitched struct {
	ID    string                                         `json:"id" api:"required"`
	Model SessionMessageSessionMessageModelSwitchedModel `json:"model" api:"required"`
	Time  SessionMessageSessionMessageModelSwitchedTime  `json:"time" api:"required"`
	// Any of "model-switched".
	Type     string         `json:"type" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Model       respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageModelSwitched) RawJSON 

func (r SessionMessageSessionMessageModelSwitched) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageModelSwitched) UnmarshalJSON 

func (r *SessionMessageSessionMessageModelSwitched) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageModelSwitchedModel 

type SessionMessageSessionMessageModelSwitchedModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageModelSwitchedModel) RawJSON 

func (r SessionMessageSessionMessageModelSwitchedModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageModelSwitchedModel) UnmarshalJSON 

func (r *SessionMessageSessionMessageModelSwitchedModel) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageModelSwitchedTime 

type SessionMessageSessionMessageModelSwitchedTime struct {
	Created float64 `json:"created" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageModelSwitchedTime) RawJSON 

func (r SessionMessageSessionMessageModelSwitchedTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageModelSwitchedTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageModelSwitchedTime) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageShell 

type SessionMessageSessionMessageShell struct {
	ID      string                                `json:"id" api:"required"`
	CallID  string                                `json:"callID" api:"required"`
	Command string                                `json:"command" api:"required"`
	Output  string                                `json:"output" api:"required"`
	Time    SessionMessageSessionMessageShellTime `json:"time" api:"required"`
	// Any of "shell".
	Type     string         `json:"type" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		CallID      respjson.Field
		Command     respjson.Field
		Output      respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageShell) RawJSON 

func (r SessionMessageSessionMessageShell) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageShell) UnmarshalJSON 

func (r *SessionMessageSessionMessageShell) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageShellTime 

type SessionMessageSessionMessageShellTime struct {
	Created   float64 `json:"created" api:"required"`
	Completed float64 `json:"completed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Completed   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageShellTime) RawJSON 

func (r SessionMessageSessionMessageShellTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageShellTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageShellTime) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageSynthetic 

type SessionMessageSessionMessageSynthetic struct {
	ID        string                                    `json:"id" api:"required"`
	SessionID string                                    `json:"sessionID" api:"required"`
	Text      string                                    `json:"text" api:"required"`
	Time      SessionMessageSessionMessageSyntheticTime `json:"time" api:"required"`
	// Any of "synthetic".
	Type     string         `json:"type" api:"required"`
	Metadata map[string]any `json:"metadata"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		SessionID   respjson.Field
		Text        respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Metadata    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageSynthetic) RawJSON 

func (r SessionMessageSessionMessageSynthetic) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageSynthetic) UnmarshalJSON 

func (r *SessionMessageSessionMessageSynthetic) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageSyntheticTime 

type SessionMessageSessionMessageSyntheticTime struct {
	Created float64 `json:"created" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageSyntheticTime) RawJSON 

func (r SessionMessageSessionMessageSyntheticTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageSyntheticTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageSyntheticTime) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageUser 

type SessionMessageSessionMessageUser struct {
	ID   string                               `json:"id" api:"required"`
	Text string                               `json:"text" api:"required"`
	Time SessionMessageSessionMessageUserTime `json:"time" api:"required"`
	// Any of "user".
	Type       string                      `json:"type" api:"required"`
	Agents     []PromptAgentAttachment     `json:"agents"`
	Files      []PromptFileAttachment      `json:"files"`
	Metadata   map[string]any              `json:"metadata"`
	References []PromptReferenceAttachment `json:"references"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Text        respjson.Field
		Time        respjson.Field
		Type        respjson.Field
		Agents      respjson.Field
		Files       respjson.Field
		Metadata    respjson.Field
		References  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageUser) RawJSON 

func (r SessionMessageSessionMessageUser) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageUser) UnmarshalJSON 

func (r *SessionMessageSessionMessageUser) UnmarshalJSON(data []byte) error

type SessionMessageSessionMessageUserTime 

type SessionMessageSessionMessageUserTime struct {
	Created float64 `json:"created" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionMessageSessionMessageUserTime) RawJSON 

func (r SessionMessageSessionMessageUserTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageSessionMessageUserTime) UnmarshalJSON 

func (r *SessionMessageSessionMessageUserTime) UnmarshalJSON(data []byte) error

type SessionMessageUnion 

type SessionMessageUnion struct {
	ID    string `json:"id"`
	Agent string `json:"agent"`
	// This field is a union of [SessionMessageSessionMessageAgentSwitchedTime],
	// [SessionMessageSessionMessageModelSwitchedTime],
	// [SessionMessageSessionMessageUserTime],
	// [SessionMessageSessionMessageSyntheticTime],
	// [SessionMessageSessionMessageShellTime],
	// [SessionMessageSessionMessageAssistantTime],
	// [SessionMessageSessionMessageCompactionTime]
	Time     SessionMessageUnionTime `json:"time"`
	Type     string                  `json:"type"`
	Metadata any                     `json:"metadata"`
	// This field is a union of [SessionMessageSessionMessageModelSwitchedModel],
	// [SessionMessageSessionMessageAssistantModel]
	Model SessionMessageUnionModel `json:"model"`
	Text  string                   `json:"text"`
	// This field is from variant [SessionMessageSessionMessageUser].
	Agents []PromptAgentAttachment `json:"agents"`
	// This field is from variant [SessionMessageSessionMessageUser].
	Files []PromptFileAttachment `json:"files"`
	// This field is from variant [SessionMessageSessionMessageUser].
	References []PromptReferenceAttachment `json:"references"`
	// This field is from variant [SessionMessageSessionMessageSynthetic].
	SessionID string `json:"sessionID"`
	// This field is from variant [SessionMessageSessionMessageShell].
	CallID string `json:"callID"`
	// This field is from variant [SessionMessageSessionMessageShell].
	Command string `json:"command"`
	// This field is from variant [SessionMessageSessionMessageShell].
	Output string `json:"output"`
	// This field is from variant [SessionMessageSessionMessageAssistant].
	Content []SessionMessageSessionMessageAssistantContentUnion `json:"content"`
	// This field is from variant [SessionMessageSessionMessageAssistant].
	Cost float64 `json:"cost"`
	// This field is from variant [SessionMessageSessionMessageAssistant].
	Error SessionErrorUnknown `json:"error"`
	// This field is from variant [SessionMessageSessionMessageAssistant].
	Finish string `json:"finish"`
	// This field is from variant [SessionMessageSessionMessageAssistant].
	Snapshot SessionMessageSessionMessageAssistantSnapshot `json:"snapshot"`
	// This field is from variant [SessionMessageSessionMessageAssistant].
	Tokens SessionMessageSessionMessageAssistantTokens `json:"tokens"`
	// This field is from variant [SessionMessageSessionMessageCompaction].
	Reason string `json:"reason"`
	// This field is from variant [SessionMessageSessionMessageCompaction].
	Summary string `json:"summary"`
	// This field is from variant [SessionMessageSessionMessageCompaction].
	Include string `json:"include"`
	JSON    struct {
		ID         respjson.Field
		Agent      respjson.Field
		Time       respjson.Field
		Type       respjson.Field
		Metadata   respjson.Field
		Model      respjson.Field
		Text       respjson.Field
		Agents     respjson.Field
		Files      respjson.Field
		References respjson.Field
		SessionID  respjson.Field
		CallID     respjson.Field
		Command    respjson.Field
		Output     respjson.Field
		Content    respjson.Field
		Cost       respjson.Field
		Error      respjson.Field
		Finish     respjson.Field
		Snapshot   respjson.Field
		Tokens     respjson.Field
		Reason     respjson.Field
		Summary    respjson.Field
		Include    respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageUnion contains all possible properties and values from SessionMessageSessionMessageAgentSwitched, SessionMessageSessionMessageModelSwitched, SessionMessageSessionMessageUser, SessionMessageSessionMessageSynthetic, SessionMessageSessionMessageShell, SessionMessageSessionMessageAssistant, SessionMessageSessionMessageCompaction.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (SessionMessageUnion) AsSessionMessageSessionMessageAgentSwitched 

func (u SessionMessageUnion) AsSessionMessageSessionMessageAgentSwitched() (v SessionMessageSessionMessageAgentSwitched)

func (SessionMessageUnion) AsSessionMessageSessionMessageAssistant 

func (u SessionMessageUnion) AsSessionMessageSessionMessageAssistant() (v SessionMessageSessionMessageAssistant)

func (SessionMessageUnion) AsSessionMessageSessionMessageCompaction 

func (u SessionMessageUnion) AsSessionMessageSessionMessageCompaction() (v SessionMessageSessionMessageCompaction)

func (SessionMessageUnion) AsSessionMessageSessionMessageModelSwitched 

func (u SessionMessageUnion) AsSessionMessageSessionMessageModelSwitched() (v SessionMessageSessionMessageModelSwitched)

func (SessionMessageUnion) AsSessionMessageSessionMessageShell 

func (u SessionMessageUnion) AsSessionMessageSessionMessageShell() (v SessionMessageSessionMessageShell)

func (SessionMessageUnion) AsSessionMessageSessionMessageSynthetic 

func (u SessionMessageUnion) AsSessionMessageSessionMessageSynthetic() (v SessionMessageSessionMessageSynthetic)

func (SessionMessageUnion) AsSessionMessageSessionMessageUser 

func (u SessionMessageUnion) AsSessionMessageSessionMessageUser() (v SessionMessageSessionMessageUser)

func (SessionMessageUnion) RawJSON 

func (u SessionMessageUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionMessageUnion) UnmarshalJSON 

func (r *SessionMessageUnion) UnmarshalJSON(data []byte) error

type SessionMessageUnionModel 

type SessionMessageUnionModel struct {
	ID         string `json:"id"`
	ProviderID string `json:"providerID"`
	Variant    string `json:"variant"`
	JSON       struct {
		ID         respjson.Field
		ProviderID respjson.Field
		Variant    respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageUnionModel is an implicit subunion of SessionMessageUnion. SessionMessageUnionModel provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the SessionMessageUnion.

func (*SessionMessageUnionModel) UnmarshalJSON 

func (r *SessionMessageUnionModel) UnmarshalJSON(data []byte) error

type SessionMessageUnionTime 

type SessionMessageUnionTime struct {
	Created   float64 `json:"created"`
	Completed float64 `json:"completed"`
	JSON      struct {
		Created   respjson.Field
		Completed respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

SessionMessageUnionTime is an implicit subunion of SessionMessageUnion. SessionMessageUnionTime provides convenient access to the sub-properties of the union.

For type safety it is recommended to directly use a variant of the SessionMessageUnion.

func (*SessionMessageUnionTime) UnmarshalJSON 

func (r *SessionMessageUnionTime) UnmarshalJSON(data []byte) error

type SessionModel 

type SessionModel struct {
	ID         string `json:"id" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	Variant    string `json:"variant"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ProviderID  respjson.Field
		Variant     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionModel) RawJSON 

func (r SessionModel) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionModel) UnmarshalJSON 

func (r *SessionModel) UnmarshalJSON(data []byte) error

type SessionNewParams 

type SessionNewParams struct {
	Directory   param.Opt[string]     `query:"directory,omitzero" json:"-"`
	Workspace   param.Opt[string]     `query:"workspace,omitzero" json:"-"`
	Agent       param.Opt[string]     `json:"agent,omitzero"`
	ParentID    param.Opt[string]     `json:"parentID,omitzero"`
	Title       param.Opt[string]     `json:"title,omitzero"`
	WorkspaceID param.Opt[string]     `json:"workspaceID,omitzero"`
	Model       SessionNewParamsModel `json:"model,omitzero"`
	Permission  []PermissionRuleParam `json:"permission,omitzero"`
	// contains filtered or unexported fields
}

func (SessionNewParams) MarshalJSON 

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

func (SessionNewParams) URLQuery 

func (r SessionNewParams) URLQuery() (v url.Values, err error)

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

func (*SessionNewParams) UnmarshalJSON 

func (r *SessionNewParams) UnmarshalJSON(data []byte) error

type SessionNewParamsModel 

type SessionNewParamsModel struct {
	ID         string            `json:"id" api:"required"`
	ProviderID string            `json:"providerID" api:"required"`
	Variant    param.Opt[string] `json:"variant,omitzero"`
	// contains filtered or unexported fields
}

The properties ID, ProviderID are required.

func (SessionNewParamsModel) MarshalJSON 

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

func (*SessionNewParamsModel) UnmarshalJSON 

func (r *SessionNewParamsModel) UnmarshalJSON(data []byte) error

type SessionNextRetryError 

type SessionNextRetryError struct {
	IsRetryable     bool              `json:"isRetryable" api:"required"`
	Message         string            `json:"message" api:"required"`
	Metadata        map[string]string `json:"metadata"`
	ResponseBody    string            `json:"responseBody"`
	ResponseHeaders map[string]string `json:"responseHeaders"`
	StatusCode      float64           `json:"statusCode"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		IsRetryable     respjson.Field
		Message         respjson.Field
		Metadata        respjson.Field
		ResponseBody    respjson.Field
		ResponseHeaders respjson.Field
		StatusCode      respjson.Field
		ExtraFields     map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionNextRetryError) RawJSON 

func (r SessionNextRetryError) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionNextRetryError) UnmarshalJSON 

func (r *SessionNextRetryError) UnmarshalJSON(data []byte) error

type SessionRespondToPermissionParams 

type SessionRespondToPermissionParams struct {
	SessionID string `path:"sessionID" api:"required" json:"-"`
	// Any of "once", "always", "reject".
	Response  SessionRespondToPermissionParamsResponse `json:"response,omitzero" api:"required"`
	Directory param.Opt[string]                        `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]                        `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionRespondToPermissionParams) MarshalJSON 

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

func (SessionRespondToPermissionParams) URLQuery 

func (r SessionRespondToPermissionParams) URLQuery() (v url.Values, err error)

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

func (*SessionRespondToPermissionParams) UnmarshalJSON 

func (r *SessionRespondToPermissionParams) UnmarshalJSON(data []byte) error

type SessionRespondToPermissionParamsResponse 

type SessionRespondToPermissionParamsResponse string
const (
	SessionRespondToPermissionParamsResponseOnce   SessionRespondToPermissionParamsResponse = "once"
	SessionRespondToPermissionParamsResponseAlways SessionRespondToPermissionParamsResponse = "always"
	SessionRespondToPermissionParamsResponseReject SessionRespondToPermissionParamsResponse = "reject"
)

type SessionRestoreRevertedMessagesParams 

type SessionRestoreRevertedMessagesParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionRestoreRevertedMessagesParams) URLQuery 

func (r SessionRestoreRevertedMessagesParams) URLQuery() (v url.Values, err error)

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

type SessionRevert 

type SessionRevert struct {
	MessageID string `json:"messageID" api:"required"`
	Diff      string `json:"diff"`
	PartID    string `json:"partID"`
	Snapshot  string `json:"snapshot"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		MessageID   respjson.Field
		Diff        respjson.Field
		PartID      respjson.Field
		Snapshot    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionRevert) RawJSON 

func (r SessionRevert) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionRevert) UnmarshalJSON 

func (r *SessionRevert) UnmarshalJSON(data []byte) error

type SessionRevertMessageParams 

type SessionRevertMessageParams struct {
	MessageID string            `json:"messageID" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	PartID    param.Opt[string] `json:"partID,omitzero"`
	// contains filtered or unexported fields
}

func (SessionRevertMessageParams) MarshalJSON 

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

func (SessionRevertMessageParams) URLQuery 

func (r SessionRevertMessageParams) URLQuery() (v url.Values, err error)

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

func (*SessionRevertMessageParams) UnmarshalJSON 

func (r *SessionRevertMessageParams) UnmarshalJSON(data []byte) error

type SessionRunShellCommandParams 

type SessionRunShellCommandParams struct {
	Agent     string                            `json:"agent" api:"required"`
	Command   string                            `json:"command" api:"required"`
	Directory param.Opt[string]                 `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]                 `query:"workspace,omitzero" json:"-"`
	MessageID param.Opt[string]                 `json:"messageID,omitzero"`
	Model     SessionRunShellCommandParamsModel `json:"model,omitzero"`
	// contains filtered or unexported fields
}

func (SessionRunShellCommandParams) MarshalJSON 

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

func (SessionRunShellCommandParams) URLQuery 

func (r SessionRunShellCommandParams) URLQuery() (v url.Values, err error)

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

func (*SessionRunShellCommandParams) UnmarshalJSON 

func (r *SessionRunShellCommandParams) UnmarshalJSON(data []byte) error

type SessionRunShellCommandParamsModel 

type SessionRunShellCommandParamsModel struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// contains filtered or unexported fields
}

The properties ModelID, ProviderID are required.

func (SessionRunShellCommandParamsModel) MarshalJSON 

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

func (*SessionRunShellCommandParamsModel) UnmarshalJSON 

func (r *SessionRunShellCommandParamsModel) UnmarshalJSON(data []byte) error

type SessionRunShellCommandResponse 

type SessionRunShellCommandResponse struct {
	Info  MessageUnion `json:"info" api:"required"`
	Parts []PartUnion  `json:"parts" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		Parts       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Created message

func (SessionRunShellCommandResponse) RawJSON 

func (r SessionRunShellCommandResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionRunShellCommandResponse) UnmarshalJSON 

func (r *SessionRunShellCommandResponse) UnmarshalJSON(data []byte) error

type SessionSendAsyncMessageParams 

type SessionSendAsyncMessageParams struct {
	Parts     []SessionSendAsyncMessageParamsPartUnion `json:"parts,omitzero" api:"required"`
	Directory param.Opt[string]                        `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]                        `query:"workspace,omitzero" json:"-"`
	Agent     param.Opt[string]                        `json:"agent,omitzero"`
	MessageID param.Opt[string]                        `json:"messageID,omitzero"`
	NoReply   param.Opt[bool]                          `json:"noReply,omitzero"`
	System    param.Opt[string]                        `json:"system,omitzero"`
	Variant   param.Opt[string]                        `json:"variant,omitzero"`
	Format    OutputFormatUnionParam                   `json:"format,omitzero"`
	Model     SessionSendAsyncMessageParamsModel       `json:"model,omitzero"`
	Tools     map[string]bool                          `json:"tools,omitzero"`
	// contains filtered or unexported fields
}

func (SessionSendAsyncMessageParams) MarshalJSON 

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

func (SessionSendAsyncMessageParams) URLQuery 

func (r SessionSendAsyncMessageParams) URLQuery() (v url.Values, err error)

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

func (*SessionSendAsyncMessageParams) UnmarshalJSON 

func (r *SessionSendAsyncMessageParams) UnmarshalJSON(data []byte) error

type SessionSendAsyncMessageParamsModel 

type SessionSendAsyncMessageParamsModel struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// contains filtered or unexported fields
}

The properties ModelID, ProviderID are required.

func (SessionSendAsyncMessageParamsModel) MarshalJSON 

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

func (*SessionSendAsyncMessageParamsModel) UnmarshalJSON 

func (r *SessionSendAsyncMessageParamsModel) UnmarshalJSON(data []byte) error

type SessionSendAsyncMessageParamsPartUnion 

type SessionSendAsyncMessageParamsPartUnion struct {
	OfTextPartInput    *TextPartInputParam    `json:",omitzero,inline"`
	OfFilePartInput    *FilePartInputParam    `json:",omitzero,inline"`
	OfAgentPartInput   *AgentPartInputParam   `json:",omitzero,inline"`
	OfSubtaskPartInput *SubtaskPartInputParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (SessionSendAsyncMessageParamsPartUnion) MarshalJSON 

func (u SessionSendAsyncMessageParamsPartUnion) MarshalJSON() ([]byte, error)

func (*SessionSendAsyncMessageParamsPartUnion) UnmarshalJSON 

func (u *SessionSendAsyncMessageParamsPartUnion) UnmarshalJSON(data []byte) error

type SessionSendCommandParams 

type SessionSendCommandParams struct {
	Arguments string                         `json:"arguments" api:"required"`
	Command   string                         `json:"command" api:"required"`
	Directory param.Opt[string]              `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]              `query:"workspace,omitzero" json:"-"`
	Agent     param.Opt[string]              `json:"agent,omitzero"`
	MessageID param.Opt[string]              `json:"messageID,omitzero"`
	Model     param.Opt[string]              `json:"model,omitzero"`
	Variant   param.Opt[string]              `json:"variant,omitzero"`
	Parts     []SessionSendCommandParamsPart `json:"parts,omitzero"`
	// contains filtered or unexported fields
}

func (SessionSendCommandParams) MarshalJSON 

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

func (SessionSendCommandParams) URLQuery 

func (r SessionSendCommandParams) URLQuery() (v url.Values, err error)

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

func (*SessionSendCommandParams) UnmarshalJSON 

func (r *SessionSendCommandParams) UnmarshalJSON(data []byte) error

type SessionSendCommandParamsPart 

type SessionSendCommandParamsPart struct {
	Mime string `json:"mime" api:"required"`
	// Any of "file".
	Type     string                   `json:"type,omitzero" api:"required"`
	URL      string                   `json:"url" api:"required"`
	ID       param.Opt[string]        `json:"id,omitzero"`
	Filename param.Opt[string]        `json:"filename,omitzero"`
	Source   FilePartSourceUnionParam `json:"source,omitzero"`
	// contains filtered or unexported fields
}

The properties Mime, Type, URL are required.

func (SessionSendCommandParamsPart) MarshalJSON 

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

func (*SessionSendCommandParamsPart) UnmarshalJSON 

func (r *SessionSendCommandParamsPart) UnmarshalJSON(data []byte) error

type SessionSendCommandResponse 

type SessionSendCommandResponse struct {
	Info  AssistantMessage `json:"info" api:"required"`
	Parts []PartUnion      `json:"parts" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Info        respjson.Field
		Parts       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionSendCommandResponse) RawJSON 

func (r SessionSendCommandResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionSendCommandResponse) UnmarshalJSON 

func (r *SessionSendCommandResponse) UnmarshalJSON(data []byte) error

type SessionService 

type SessionService struct {

	// Experimental HttpApi session routes.
	Message SessionMessageService
	// Experimental HttpApi session routes.
	Share SessionShareService
	// contains filtered or unexported fields
}

Experimental HttpApi session routes.

SessionService contains methods and other services that help with interacting with the opencode-stainless 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 NewSessionService method instead.

func NewSessionService 

func NewSessionService(opts ...option.RequestOption) (r SessionService)

NewSessionService 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 (*SessionService) Abort 

func (r *SessionService) Abort(ctx context.Context, sessionID string, body SessionAbortParams, opts ...option.RequestOption) (res *bool, err error)

Abort an active session and stop any ongoing AI processing or command execution.

func (*SessionService) Delete 

func (r *SessionService) Delete(ctx context.Context, sessionID string, body SessionDeleteParams, opts ...option.RequestOption) (res *bool, err error)

Delete a session and permanently remove all associated data, including messages and history.

func (*SessionService) Fork 

func (r *SessionService) Fork(ctx context.Context, sessionID string, params SessionForkParams, opts ...option.RequestOption) (res *Session, err error)

Create a new session by forking an existing session at a specific message point.

func (*SessionService) Get 

func (r *SessionService) Get(ctx context.Context, sessionID string, query SessionGetParams, opts ...option.RequestOption) (res *Session, err error)

Retrieve detailed information about a specific OpenCode session.

func (*SessionService) GetChildren 

func (r *SessionService) GetChildren(ctx context.Context, sessionID string, query SessionGetChildrenParams, opts ...option.RequestOption) (res *[]Session, err error)

Retrieve all child sessions that were forked from the specified parent session.

func (*SessionService) GetDiff 

func (r *SessionService) GetDiff(ctx context.Context, sessionID string, query SessionGetDiffParams, opts ...option.RequestOption) (res *[]SnapshotFileDiff, err error)

Get the file changes (diff) that resulted from a specific user message in the session.

func (*SessionService) GetStatus 

func (r *SessionService) GetStatus(ctx context.Context, query SessionGetStatusParams, opts ...option.RequestOption) (res *SessionGetStatusResponse, err error)

Retrieve the current status of all sessions, including active, idle, and completed states.

func (*SessionService) GetTodo 

func (r *SessionService) GetTodo(ctx context.Context, sessionID string, query SessionGetTodoParams, opts ...option.RequestOption) (res *[]Todo, err error)

Retrieve the todo list associated with a specific session, showing tasks and action items.

func (*SessionService) Initialize 

func (r *SessionService) Initialize(ctx context.Context, sessionID string, params SessionInitializeParams, opts ...option.RequestOption) (res *bool, err error)

Analyze the current application and create an AGENTS.md file with project-specific agent configurations.

func (*SessionService) List 

func (r *SessionService) List(ctx context.Context, query SessionListParams, opts ...option.RequestOption) (res *[]Session, err error)

Get a list of all OpenCode sessions, sorted by most recently updated.

func (*SessionService) New 

func (r *SessionService) New(ctx context.Context, params SessionNewParams, opts ...option.RequestOption) (res *Session, err error)

Create a new OpenCode session for interacting with AI assistants and managing conversations.

func (*SessionService) RespondToPermission deprecated 

func (r *SessionService) RespondToPermission(ctx context.Context, permissionID string, params SessionRespondToPermissionParams, opts ...option.RequestOption) (res *bool, err error)

Approve or deny a permission request from the AI assistant.

Deprecated: deprecated

func (*SessionService) RestoreRevertedMessages 

func (r *SessionService) RestoreRevertedMessages(ctx context.Context, sessionID string, body SessionRestoreRevertedMessagesParams, opts ...option.RequestOption) (res *Session, err error)

Restore all previously reverted messages in a session.

func (*SessionService) RevertMessage 

func (r *SessionService) RevertMessage(ctx context.Context, sessionID string, params SessionRevertMessageParams, opts ...option.RequestOption) (res *Session, err error)

Revert a specific message in a session, undoing its effects and restoring the previous state.

func (*SessionService) RunShellCommand 

func (r *SessionService) RunShellCommand(ctx context.Context, sessionID string, params SessionRunShellCommandParams, opts ...option.RequestOption) (res *SessionRunShellCommandResponse, err error)

Execute a shell command within the session context and return the AI's response.

func (*SessionService) SendAsyncMessage 

func (r *SessionService) SendAsyncMessage(ctx context.Context, sessionID string, params SessionSendAsyncMessageParams, opts ...option.RequestOption) (err error)

Create and send a new message to a session asynchronously, starting the session if needed and returning immediately.

func (*SessionService) SendCommand 

func (r *SessionService) SendCommand(ctx context.Context, sessionID string, params SessionSendCommandParams, opts ...option.RequestOption) (res *SessionSendCommandResponse, err error)

Send a new command to a session for execution by the AI assistant.

func (*SessionService) Summarize 

func (r *SessionService) Summarize(ctx context.Context, sessionID string, params SessionSummarizeParams, opts ...option.RequestOption) (res *bool, err error)

Generate a concise summary of the session using AI compaction to preserve key information.

func (*SessionService) Update 

func (r *SessionService) Update(ctx context.Context, sessionID string, params SessionUpdateParams, opts ...option.RequestOption) (res *Session, err error)

Update properties of an existing session, such as title or other metadata.

type SessionShare 

type SessionShare struct {
	URL string `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionShare) RawJSON 

func (r SessionShare) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionShare) UnmarshalJSON 

func (r *SessionShare) UnmarshalJSON(data []byte) error

type SessionShareDeleteParams 

type SessionShareDeleteParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionShareDeleteParams) URLQuery 

func (r SessionShareDeleteParams) URLQuery() (v url.Values, err error)

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

type SessionShareNewParams 

type SessionShareNewParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SessionShareNewParams) URLQuery 

func (r SessionShareNewParams) URLQuery() (v url.Values, err error)

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

type SessionShareService 

type SessionShareService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi session routes.

SessionShareService contains methods and other services that help with interacting with the opencode-stainless 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 NewSessionShareService method instead.

func NewSessionShareService 

func NewSessionShareService(opts ...option.RequestOption) (r SessionShareService)

NewSessionShareService 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 (*SessionShareService) Delete 

func (r *SessionShareService) Delete(ctx context.Context, sessionID string, body SessionShareDeleteParams, opts ...option.RequestOption) (res *Session, err error)

Remove the shareable link for a session, making it private again.

func (*SessionShareService) New 

func (r *SessionShareService) New(ctx context.Context, sessionID string, body SessionShareNewParams, opts ...option.RequestOption) (res *Session, err error)

Create a shareable link for a session, allowing others to view the conversation.

type SessionSummarizeParams 

type SessionSummarizeParams struct {
	ModelID    string            `json:"modelID" api:"required"`
	ProviderID string            `json:"providerID" api:"required"`
	Directory  param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace  param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Auto       param.Opt[bool]   `json:"auto,omitzero"`
	// contains filtered or unexported fields
}

func (SessionSummarizeParams) MarshalJSON 

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

func (SessionSummarizeParams) URLQuery 

func (r SessionSummarizeParams) URLQuery() (v url.Values, err error)

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

func (*SessionSummarizeParams) UnmarshalJSON 

func (r *SessionSummarizeParams) UnmarshalJSON(data []byte) error

type SessionSummary 

type SessionSummary struct {
	Additions float64            `json:"additions" api:"required"`
	Deletions float64            `json:"deletions" api:"required"`
	Files     float64            `json:"files" api:"required"`
	Diffs     []SnapshotFileDiff `json:"diffs"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Additions   respjson.Field
		Deletions   respjson.Field
		Files       respjson.Field
		Diffs       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionSummary) RawJSON 

func (r SessionSummary) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionSummary) UnmarshalJSON 

func (r *SessionSummary) UnmarshalJSON(data []byte) error

type SessionTime 

type SessionTime struct {
	Created    int64   `json:"created" api:"required"`
	Updated    int64   `json:"updated" api:"required"`
	Archived   float64 `json:"archived"`
	Compacting int64   `json:"compacting"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Created     respjson.Field
		Updated     respjson.Field
		Archived    respjson.Field
		Compacting  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionTime) RawJSON 

func (r SessionTime) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionTime) UnmarshalJSON 

func (r *SessionTime) UnmarshalJSON(data []byte) error

type SessionTokens 

type SessionTokens struct {
	Cache     SessionTokensCache `json:"cache" api:"required"`
	Input     float64            `json:"input" api:"required"`
	Output    float64            `json:"output" api:"required"`
	Reasoning float64            `json:"reasoning" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Cache       respjson.Field
		Input       respjson.Field
		Output      respjson.Field
		Reasoning   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionTokens) RawJSON 

func (r SessionTokens) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionTokens) UnmarshalJSON 

func (r *SessionTokens) UnmarshalJSON(data []byte) error

type SessionTokensCache 

type SessionTokensCache struct {
	Read  float64 `json:"read" api:"required"`
	Write float64 `json:"write" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Read        respjson.Field
		Write       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SessionTokensCache) RawJSON 

func (r SessionTokensCache) RawJSON() string

Returns the unmodified JSON received from the API

func (*SessionTokensCache) UnmarshalJSON 

func (r *SessionTokensCache) UnmarshalJSON(data []byte) error

type SessionUpdateParams 

type SessionUpdateParams struct {
	Directory  param.Opt[string]       `query:"directory,omitzero" json:"-"`
	Workspace  param.Opt[string]       `query:"workspace,omitzero" json:"-"`
	Title      param.Opt[string]       `json:"title,omitzero"`
	Permission []PermissionRuleParam   `json:"permission,omitzero"`
	Time       SessionUpdateParamsTime `json:"time,omitzero"`
	// contains filtered or unexported fields
}

func (SessionUpdateParams) MarshalJSON 

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

func (SessionUpdateParams) URLQuery 

func (r SessionUpdateParams) URLQuery() (v url.Values, err error)

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

func (*SessionUpdateParams) UnmarshalJSON 

func (r *SessionUpdateParams) UnmarshalJSON(data []byte) error

type SessionUpdateParamsTime 

type SessionUpdateParamsTime struct {
	Archived param.Opt[float64] `json:"archived,omitzero"`
	// contains filtered or unexported fields
}

func (SessionUpdateParamsTime) MarshalJSON 

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

func (*SessionUpdateParamsTime) UnmarshalJSON 

func (r *SessionUpdateParamsTime) UnmarshalJSON(data []byte) error

type SkillListParams 

type SkillListParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SkillListParams) URLQuery 

func (r SkillListParams) URLQuery() (v url.Values, err error)

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

type SkillListResponse 

type SkillListResponse struct {
	Content     string `json:"content" api:"required"`
	Location    string `json:"location" api:"required"`
	Name        string `json:"name" api:"required"`
	Description string `json:"description"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		Location    respjson.Field
		Name        respjson.Field
		Description respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SkillListResponse) RawJSON 

func (r SkillListResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SkillListResponse) UnmarshalJSON 

func (r *SkillListResponse) UnmarshalJSON(data []byte) error

type SkillService 

type SkillService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

SkillService contains methods and other services that help with interacting with the opencode-stainless 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 NewSkillService method instead.

func NewSkillService 

func NewSkillService(opts ...option.RequestOption) (r SkillService)

NewSkillService 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 (*SkillService) List 

func (r *SkillService) List(ctx context.Context, query SkillListParams, opts ...option.RequestOption) (res *[]SkillListResponse, err error)

Get a list of all available skills in the OpenCode system.

type SnapshotFileDiff 

type SnapshotFileDiff struct {
	Additions float64 `json:"additions" api:"required"`
	Deletions float64 `json:"deletions" api:"required"`
	File      string  `json:"file"`
	Patch     string  `json:"patch"`
	// Any of "added", "deleted", "modified".
	Status SnapshotFileDiffStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Additions   respjson.Field
		Deletions   respjson.Field
		File        respjson.Field
		Patch       respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SnapshotFileDiff) RawJSON 

func (r SnapshotFileDiff) RawJSON() string

Returns the unmodified JSON received from the API

func (*SnapshotFileDiff) UnmarshalJSON 

func (r *SnapshotFileDiff) UnmarshalJSON(data []byte) error

type SnapshotFileDiffStatus 

type SnapshotFileDiffStatus string
const (
	SnapshotFileDiffStatusAdded    SnapshotFileDiffStatus = "added"
	SnapshotFileDiffStatusDeleted  SnapshotFileDiffStatus = "deleted"
	SnapshotFileDiffStatusModified SnapshotFileDiffStatus = "modified"
)

type StructuredOutputError 

type StructuredOutputError struct {
	Data StructuredOutputErrorData `json:"data" api:"required"`
	// Any of "StructuredOutputError".
	Name StructuredOutputErrorName `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (StructuredOutputError) RawJSON 

func (r StructuredOutputError) RawJSON() string

Returns the unmodified JSON received from the API

func (*StructuredOutputError) UnmarshalJSON 

func (r *StructuredOutputError) UnmarshalJSON(data []byte) error

type StructuredOutputErrorData 

type StructuredOutputErrorData struct {
	Message string `json:"message" api:"required"`
	Retries int64  `json:"retries" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Retries     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (StructuredOutputErrorData) RawJSON 

func (r StructuredOutputErrorData) RawJSON() string

Returns the unmodified JSON received from the API

func (*StructuredOutputErrorData) UnmarshalJSON 

func (r *StructuredOutputErrorData) UnmarshalJSON(data []byte) error

type StructuredOutputErrorName 

type StructuredOutputErrorName string
const (
	StructuredOutputErrorNameStructuredOutputError StructuredOutputErrorName = "StructuredOutputError"
)

type SubtaskPartInputModelParam 

type SubtaskPartInputModelParam struct {
	ModelID    string `json:"modelID" api:"required"`
	ProviderID string `json:"providerID" api:"required"`
	// contains filtered or unexported fields
}

The properties ModelID, ProviderID are required.

func (SubtaskPartInputModelParam) MarshalJSON 

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

func (*SubtaskPartInputModelParam) UnmarshalJSON 

func (r *SubtaskPartInputModelParam) UnmarshalJSON(data []byte) error

type SubtaskPartInputParam 

type SubtaskPartInputParam struct {
	Agent       string `json:"agent" api:"required"`
	Description string `json:"description" api:"required"`
	Prompt      string `json:"prompt" api:"required"`
	// Any of "subtask".
	Type    SubtaskPartInputType       `json:"type,omitzero" api:"required"`
	ID      param.Opt[string]          `json:"id,omitzero"`
	Command param.Opt[string]          `json:"command,omitzero"`
	Model   SubtaskPartInputModelParam `json:"model,omitzero"`
	// contains filtered or unexported fields
}

The properties Agent, Description, Prompt, Type are required.

func (SubtaskPartInputParam) MarshalJSON 

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

func (*SubtaskPartInputParam) UnmarshalJSON 

func (r *SubtaskPartInputParam) UnmarshalJSON(data []byte) error

type SubtaskPartInputType 

type SubtaskPartInputType string
const (
	SubtaskPartInputTypeSubtask SubtaskPartInputType = "subtask"
)

type SyncListHistoryParams 

type SyncListHistoryParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Body      map[string]int64
	// contains filtered or unexported fields
}

func (SyncListHistoryParams) MarshalJSON 

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

func (SyncListHistoryParams) URLQuery 

func (r SyncListHistoryParams) URLQuery() (v url.Values, err error)

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

func (*SyncListHistoryParams) UnmarshalJSON 

func (r *SyncListHistoryParams) UnmarshalJSON(data []byte) error

type SyncListHistoryResponse 

type SyncListHistoryResponse struct {
	ID          string         `json:"id" api:"required"`
	AggregateID string         `json:"aggregate_id" api:"required"`
	Data        map[string]any `json:"data" api:"required"`
	Seq         int64          `json:"seq" api:"required"`
	Type        string         `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AggregateID respjson.Field
		Data        respjson.Field
		Seq         respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (SyncListHistoryResponse) RawJSON 

func (r SyncListHistoryResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SyncListHistoryResponse) UnmarshalJSON 

func (r *SyncListHistoryResponse) UnmarshalJSON(data []byte) error

type SyncReplayParams 

type SyncReplayParams struct {
	BodyDirectory  string                  `json:"directory" api:"required"`
	Events         []SyncReplayParamsEvent `json:"events,omitzero" api:"required"`
	QueryDirectory param.Opt[string]       `query:"directory,omitzero" json:"-"`
	Workspace      param.Opt[string]       `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SyncReplayParams) MarshalJSON 

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

func (SyncReplayParams) URLQuery 

func (r SyncReplayParams) URLQuery() (v url.Values, err error)

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

func (*SyncReplayParams) UnmarshalJSON 

func (r *SyncReplayParams) UnmarshalJSON(data []byte) error

type SyncReplayParamsEvent 

type SyncReplayParamsEvent struct {
	ID          string         `json:"id" api:"required"`
	AggregateID string         `json:"aggregateID" api:"required"`
	Data        map[string]any `json:"data,omitzero" api:"required"`
	Seq         int64          `json:"seq" api:"required"`
	Type        string         `json:"type" api:"required"`
	// contains filtered or unexported fields
}

The properties ID, AggregateID, Data, Seq, Type are required.

func (SyncReplayParamsEvent) MarshalJSON 

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

func (*SyncReplayParamsEvent) UnmarshalJSON 

func (r *SyncReplayParamsEvent) UnmarshalJSON(data []byte) error

type SyncReplayResponse 

type SyncReplayResponse struct {
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Replayed sync events

func (SyncReplayResponse) RawJSON 

func (r SyncReplayResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SyncReplayResponse) UnmarshalJSON 

func (r *SyncReplayResponse) UnmarshalJSON(data []byte) error

type SyncService 

type SyncService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi sync routes.

SyncService contains methods and other services that help with interacting with the opencode-stainless 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 NewSyncService method instead.

func NewSyncService 

func NewSyncService(opts ...option.RequestOption) (r SyncService)

NewSyncService 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 (*SyncService) ListHistory 

func (r *SyncService) ListHistory(ctx context.Context, params SyncListHistoryParams, opts ...option.RequestOption) (res *[]SyncListHistoryResponse, err error)

List sync events for all aggregates. Keys are aggregate IDs the client already knows about, values are the last known sequence ID. Events with seq > value are returned for those aggregates. Aggregates not listed in the input get their full history.

func (*SyncService) Replay 

func (r *SyncService) Replay(ctx context.Context, params SyncReplayParams, opts ...option.RequestOption) (res *SyncReplayResponse, err error)

Validate and replay a complete sync event history.

func (*SyncService) Start 

func (r *SyncService) Start(ctx context.Context, body SyncStartParams, opts ...option.RequestOption) (res *bool, err error)

Start sync loops for workspaces in the current project that have active sessions.

func (*SyncService) Steal 

func (r *SyncService) Steal(ctx context.Context, params SyncStealParams, opts ...option.RequestOption) (res *SyncStealResponse, err error)

Update a session to belong to the current workspace through the sync event system.

type SyncStartParams 

type SyncStartParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SyncStartParams) URLQuery 

func (r SyncStartParams) URLQuery() (v url.Values, err error)

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

type SyncStealParams 

type SyncStealParams struct {
	SessionID string            `json:"sessionID" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (SyncStealParams) MarshalJSON 

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

func (SyncStealParams) URLQuery 

func (r SyncStealParams) URLQuery() (v url.Values, err error)

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

func (*SyncStealParams) UnmarshalJSON 

func (r *SyncStealParams) UnmarshalJSON(data []byte) error

type SyncStealResponse 

type SyncStealResponse struct {
	SessionID string `json:"sessionID" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SessionID   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Session stolen into workspace

func (SyncStealResponse) RawJSON 

func (r SyncStealResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SyncStealResponse) UnmarshalJSON 

func (r *SyncStealResponse) UnmarshalJSON(data []byte) error

type TextPartInputParam 

type TextPartInputParam struct {
	Text string `json:"text" api:"required"`
	// Any of "text".
	Type      TextPartInputType      `json:"type,omitzero" api:"required"`
	ID        param.Opt[string]      `json:"id,omitzero"`
	Ignored   param.Opt[bool]        `json:"ignored,omitzero"`
	Synthetic param.Opt[bool]        `json:"synthetic,omitzero"`
	Metadata  map[string]any         `json:"metadata,omitzero"`
	Time      TextPartInputTimeParam `json:"time,omitzero"`
	// contains filtered or unexported fields
}

The properties Text, Type are required.

func (TextPartInputParam) MarshalJSON 

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

func (*TextPartInputParam) UnmarshalJSON 

func (r *TextPartInputParam) UnmarshalJSON(data []byte) error

type TextPartInputTimeParam 

type TextPartInputTimeParam struct {
	Start int64            `json:"start" api:"required"`
	End   param.Opt[int64] `json:"end,omitzero"`
	// contains filtered or unexported fields
}

The property Start is required.

func (TextPartInputTimeParam) MarshalJSON 

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

func (*TextPartInputTimeParam) UnmarshalJSON 

func (r *TextPartInputTimeParam) UnmarshalJSON(data []byte) error

type TextPartInputType 

type TextPartInputType string
const (
	TextPartInputTypeText TextPartInputType = "text"
)

type Todo 

type Todo struct {
	// Brief description of the task
	Content string `json:"content" api:"required"`
	// Priority level of the task: high, medium, low
	Priority string `json:"priority" api:"required"`
	// Current status of the task: pending, in_progress, completed, cancelled
	Status string `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		Priority    respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Todo) RawJSON 

func (r Todo) RawJSON() string

Returns the unmodified JSON received from the API

func (*Todo) UnmarshalJSON 

func (r *Todo) UnmarshalJSON(data []byte) error

type ToolFileContent 

type ToolFileContent struct {
	Mime string `json:"mime" api:"required"`
	// Any of "file".
	Type ToolFileContentType `json:"type" api:"required"`
	Uri  string              `json:"uri" api:"required"`
	Name string              `json:"name"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Mime        respjson.Field
		Type        respjson.Field
		Uri         respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ToolFileContent) RawJSON 

func (r ToolFileContent) RawJSON() string

Returns the unmodified JSON received from the API

func (*ToolFileContent) UnmarshalJSON 

func (r *ToolFileContent) UnmarshalJSON(data []byte) error

type ToolFileContentType 

type ToolFileContentType string
const (
	ToolFileContentTypeFile ToolFileContentType = "file"
)

type ToolTextContent 

type ToolTextContent struct {
	Text string `json:"text" api:"required"`
	// Any of "text".
	Type ToolTextContentType `json:"type" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ToolTextContent) RawJSON 

func (r ToolTextContent) RawJSON() string

Returns the unmodified JSON received from the API

func (*ToolTextContent) UnmarshalJSON 

func (r *ToolTextContent) UnmarshalJSON(data []byte) error

type ToolTextContentType 

type ToolTextContentType string
const (
	ToolTextContentTypeText ToolTextContentType = "text"
)

type TuiAppendPromptParams 

type TuiAppendPromptParams struct {
	Text      string            `json:"text" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiAppendPromptParams) MarshalJSON 

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

func (TuiAppendPromptParams) URLQuery 

func (r TuiAppendPromptParams) URLQuery() (v url.Values, err error)

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

func (*TuiAppendPromptParams) UnmarshalJSON 

func (r *TuiAppendPromptParams) UnmarshalJSON(data []byte) error

type TuiClearPromptParams 

type TuiClearPromptParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiClearPromptParams) URLQuery 

func (r TuiClearPromptParams) URLQuery() (v url.Values, err error)

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

type TuiControlGetNextRequestParams 

type TuiControlGetNextRequestParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiControlGetNextRequestParams) URLQuery 

func (r TuiControlGetNextRequestParams) URLQuery() (v url.Values, err error)

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

type TuiControlGetNextRequestResponse 

type TuiControlGetNextRequestResponse struct {
	Body any    `json:"body" api:"required"`
	Path string `json:"path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Body        respjson.Field
		Path        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Next TUI request

func (TuiControlGetNextRequestResponse) RawJSON 

func (r TuiControlGetNextRequestResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*TuiControlGetNextRequestResponse) UnmarshalJSON 

func (r *TuiControlGetNextRequestResponse) UnmarshalJSON(data []byte) error

type TuiControlService 

type TuiControlService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi TUI routes.

TuiControlService contains methods and other services that help with interacting with the opencode-stainless 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 NewTuiControlService method instead.

func NewTuiControlService 

func NewTuiControlService(opts ...option.RequestOption) (r TuiControlService)

NewTuiControlService 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 (*TuiControlService) GetNextRequest 

func (r *TuiControlService) GetNextRequest(ctx context.Context, query TuiControlGetNextRequestParams, opts ...option.RequestOption) (res *TuiControlGetNextRequestResponse, err error)

Retrieve the next TUI request from the queue for processing.

func (*TuiControlService) SubmitResponse 

func (r *TuiControlService) SubmitResponse(ctx context.Context, params TuiControlSubmitResponseParams, opts ...option.RequestOption) (res *bool, err error)

Submit a response to the TUI request queue to complete a pending request.

type TuiControlSubmitResponseParams 

type TuiControlSubmitResponseParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	Body      any
	// contains filtered or unexported fields
}

func (TuiControlSubmitResponseParams) MarshalJSON 

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

func (TuiControlSubmitResponseParams) URLQuery 

func (r TuiControlSubmitResponseParams) URLQuery() (v url.Values, err error)

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

func (*TuiControlSubmitResponseParams) UnmarshalJSON 

func (r *TuiControlSubmitResponseParams) UnmarshalJSON(data []byte) error

type TuiExecuteCommandParams 

type TuiExecuteCommandParams struct {
	Command   string            `json:"command" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiExecuteCommandParams) MarshalJSON 

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

func (TuiExecuteCommandParams) URLQuery 

func (r TuiExecuteCommandParams) URLQuery() (v url.Values, err error)

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

func (*TuiExecuteCommandParams) UnmarshalJSON 

func (r *TuiExecuteCommandParams) UnmarshalJSON(data []byte) error

type TuiOpenHelpParams 

type TuiOpenHelpParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiOpenHelpParams) URLQuery 

func (r TuiOpenHelpParams) URLQuery() (v url.Values, err error)

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

type TuiOpenModelsParams 

type TuiOpenModelsParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiOpenModelsParams) URLQuery 

func (r TuiOpenModelsParams) URLQuery() (v url.Values, err error)

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

type TuiOpenSessionsParams 

type TuiOpenSessionsParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiOpenSessionsParams) URLQuery 

func (r TuiOpenSessionsParams) URLQuery() (v url.Values, err error)

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

type TuiOpenThemesParams 

type TuiOpenThemesParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiOpenThemesParams) URLQuery 

func (r TuiOpenThemesParams) URLQuery() (v url.Values, err error)

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

type TuiPublishParams 

type TuiPublishParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`

	// This field is a request body variant, only one variant field can be set.
	OfEventTuiPromptAppend *TuiPublishParamsBodyEventTuiPromptAppend `json:",inline"`
	// This field is a request body variant, only one variant field can be set.
	OfEventTuiCommandExecute *TuiPublishParamsBodyEventTuiCommandExecute `json:",inline"`
	// This field is a request body variant, only one variant field can be set.
	OfEventTuiToastShow *TuiPublishParamsBodyEventTuiToastShow `json:",inline"`
	// This field is a request body variant, only one variant field can be set.
	OfEventTuiSessionSelect *TuiPublishParamsBodyEventTuiSessionSelect `json:",inline"`
	// contains filtered or unexported fields
}

func (TuiPublishParams) MarshalJSON 

func (u TuiPublishParams) MarshalJSON() ([]byte, error)

func (TuiPublishParams) URLQuery 

func (r TuiPublishParams) URLQuery() (v url.Values, err error)

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

func (*TuiPublishParams) UnmarshalJSON 

func (r *TuiPublishParams) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiCommandExecute 

type TuiPublishParamsBodyEventTuiCommandExecute struct {
	Properties TuiPublishParamsBodyEventTuiCommandExecuteProperties `json:"properties,omitzero" api:"required"`
	// Any of "tui.command.execute".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Properties, Type are required.

func (TuiPublishParamsBodyEventTuiCommandExecute) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiCommandExecute) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiCommandExecute) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiCommandExecuteProperties 

type TuiPublishParamsBodyEventTuiCommandExecuteProperties struct {
	Command string `json:"command,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The property Command is required.

func (TuiPublishParamsBodyEventTuiCommandExecuteProperties) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiCommandExecuteProperties) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiCommandExecuteProperties) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiPromptAppend 

type TuiPublishParamsBodyEventTuiPromptAppend struct {
	Properties TuiPublishParamsBodyEventTuiPromptAppendProperties `json:"properties,omitzero" api:"required"`
	// Any of "tui.prompt.append".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Properties, Type are required.

func (TuiPublishParamsBodyEventTuiPromptAppend) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiPromptAppend) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiPromptAppend) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiPromptAppendProperties 

type TuiPublishParamsBodyEventTuiPromptAppendProperties struct {
	Text string `json:"text" api:"required"`
	// contains filtered or unexported fields
}

The property Text is required.

func (TuiPublishParamsBodyEventTuiPromptAppendProperties) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiPromptAppendProperties) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiPromptAppendProperties) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiSessionSelect 

type TuiPublishParamsBodyEventTuiSessionSelect struct {
	Properties TuiPublishParamsBodyEventTuiSessionSelectProperties `json:"properties,omitzero" api:"required"`
	// Any of "tui.session.select".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Properties, Type are required.

func (TuiPublishParamsBodyEventTuiSessionSelect) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiSessionSelect) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiSessionSelect) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiSessionSelectProperties 

type TuiPublishParamsBodyEventTuiSessionSelectProperties struct {
	// Session ID to navigate to
	SessionID string `json:"sessionID" api:"required"`
	// contains filtered or unexported fields
}

The property SessionID is required.

func (TuiPublishParamsBodyEventTuiSessionSelectProperties) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiSessionSelectProperties) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiSessionSelectProperties) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiToastShow 

type TuiPublishParamsBodyEventTuiToastShow struct {
	Properties TuiPublishParamsBodyEventTuiToastShowProperties `json:"properties,omitzero" api:"required"`
	// Any of "tui.toast.show".
	Type string `json:"type,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The properties Properties, Type are required.

func (TuiPublishParamsBodyEventTuiToastShow) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiToastShow) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiToastShow) UnmarshalJSON(data []byte) error

type TuiPublishParamsBodyEventTuiToastShowProperties 

type TuiPublishParamsBodyEventTuiToastShowProperties struct {
	Message string `json:"message" api:"required"`
	// Any of "info", "success", "warning", "error".
	Variant  string            `json:"variant,omitzero" api:"required"`
	Duration param.Opt[int64]  `json:"duration,omitzero"`
	Title    param.Opt[string] `json:"title,omitzero"`
	// contains filtered or unexported fields
}

The properties Message, Variant are required.

func (TuiPublishParamsBodyEventTuiToastShowProperties) MarshalJSON 

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

func (*TuiPublishParamsBodyEventTuiToastShowProperties) UnmarshalJSON 

func (r *TuiPublishParamsBodyEventTuiToastShowProperties) UnmarshalJSON(data []byte) error

type TuiSelectSessionParams 

type TuiSelectSessionParams struct {
	// Session ID to navigate to
	SessionID string            `json:"sessionID" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiSelectSessionParams) MarshalJSON 

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

func (TuiSelectSessionParams) URLQuery 

func (r TuiSelectSessionParams) URLQuery() (v url.Values, err error)

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

func (*TuiSelectSessionParams) UnmarshalJSON 

func (r *TuiSelectSessionParams) UnmarshalJSON(data []byte) error

type TuiService 

type TuiService struct {

	// Experimental HttpApi TUI routes.
	Control TuiControlService
	// contains filtered or unexported fields
}

Experimental HttpApi TUI routes.

TuiService contains methods and other services that help with interacting with the opencode-stainless 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 NewTuiService method instead.

func NewTuiService 

func NewTuiService(opts ...option.RequestOption) (r TuiService)

NewTuiService 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 (*TuiService) AppendPrompt 

func (r *TuiService) AppendPrompt(ctx context.Context, params TuiAppendPromptParams, opts ...option.RequestOption) (res *bool, err error)

Append prompt to the TUI.

func (*TuiService) ClearPrompt 

func (r *TuiService) ClearPrompt(ctx context.Context, body TuiClearPromptParams, opts ...option.RequestOption) (res *bool, err error)

Clear the prompt.

func (*TuiService) ExecuteCommand 

func (r *TuiService) ExecuteCommand(ctx context.Context, params TuiExecuteCommandParams, opts ...option.RequestOption) (res *bool, err error)

Execute a TUI command.

func (*TuiService) OpenHelp 

func (r *TuiService) OpenHelp(ctx context.Context, body TuiOpenHelpParams, opts ...option.RequestOption) (res *bool, err error)

Open the help dialog in the TUI to display user assistance information.

func (*TuiService) OpenModels 

func (r *TuiService) OpenModels(ctx context.Context, body TuiOpenModelsParams, opts ...option.RequestOption) (res *bool, err error)

Open the model dialog.

func (*TuiService) OpenSessions 

func (r *TuiService) OpenSessions(ctx context.Context, body TuiOpenSessionsParams, opts ...option.RequestOption) (res *bool, err error)

Open the session dialog.

func (*TuiService) OpenThemes 

func (r *TuiService) OpenThemes(ctx context.Context, body TuiOpenThemesParams, opts ...option.RequestOption) (res *bool, err error)

Open the theme dialog.

func (*TuiService) Publish 

func (r *TuiService) Publish(ctx context.Context, params TuiPublishParams, opts ...option.RequestOption) (res *bool, err error)

Publish a TUI event.

func (*TuiService) SelectSession 

func (r *TuiService) SelectSession(ctx context.Context, params TuiSelectSessionParams, opts ...option.RequestOption) (res *bool, err error)

Navigate the TUI to display the specified session.

func (*TuiService) ShowToast 

func (r *TuiService) ShowToast(ctx context.Context, params TuiShowToastParams, opts ...option.RequestOption) (res *bool, err error)

Show a toast notification in the TUI.

func (*TuiService) SubmitPrompt 

func (r *TuiService) SubmitPrompt(ctx context.Context, body TuiSubmitPromptParams, opts ...option.RequestOption) (res *bool, err error)

Submit the prompt.

type TuiShowToastParams 

type TuiShowToastParams struct {
	Message string `json:"message" api:"required"`
	// Any of "info", "success", "warning", "error".
	Variant   TuiShowToastParamsVariant `json:"variant,omitzero" api:"required"`
	Directory param.Opt[string]         `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]         `query:"workspace,omitzero" json:"-"`
	Duration  param.Opt[int64]          `json:"duration,omitzero"`
	Title     param.Opt[string]         `json:"title,omitzero"`
	// contains filtered or unexported fields
}

func (TuiShowToastParams) MarshalJSON 

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

func (TuiShowToastParams) URLQuery 

func (r TuiShowToastParams) URLQuery() (v url.Values, err error)

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

func (*TuiShowToastParams) UnmarshalJSON 

func (r *TuiShowToastParams) UnmarshalJSON(data []byte) error

type TuiShowToastParamsVariant 

type TuiShowToastParamsVariant string
const (
	TuiShowToastParamsVariantInfo    TuiShowToastParamsVariant = "info"
	TuiShowToastParamsVariantSuccess TuiShowToastParamsVariant = "success"
	TuiShowToastParamsVariantWarning TuiShowToastParamsVariant = "warning"
	TuiShowToastParamsVariantError   TuiShowToastParamsVariant = "error"
)

type TuiSubmitPromptParams 

type TuiSubmitPromptParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TuiSubmitPromptParams) URLQuery 

func (r TuiSubmitPromptParams) URLQuery() (v url.Values, err error)

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

type UnknownError 

type UnknownError struct {
	Data UnknownErrorData `json:"data" api:"required"`
	// Any of "UnknownError".
	Name UnknownErrorName `json:"name" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Name        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (UnknownError) RawJSON 

func (r UnknownError) RawJSON() string

Returns the unmodified JSON received from the API

func (*UnknownError) UnmarshalJSON 

func (r *UnknownError) UnmarshalJSON(data []byte) error

type UnknownErrorData 

type UnknownErrorData struct {
	Message string `json:"message" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (UnknownErrorData) RawJSON 

func (r UnknownErrorData) RawJSON() string

Returns the unmodified JSON received from the API

func (*UnknownErrorData) UnmarshalJSON 

func (r *UnknownErrorData) UnmarshalJSON(data []byte) error

type UnknownErrorName 

type UnknownErrorName string
const (
	UnknownErrorNameUnknownError UnknownErrorName = "UnknownError"
)

type VcApplyPatchParams 

type VcApplyPatchParams struct {
	Patch     string            `json:"patch" api:"required"`
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (VcApplyPatchParams) MarshalJSON 

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

func (VcApplyPatchParams) URLQuery 

func (r VcApplyPatchParams) URLQuery() (v url.Values, err error)

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

func (*VcApplyPatchParams) UnmarshalJSON 

func (r *VcApplyPatchParams) UnmarshalJSON(data []byte) error

type VcApplyPatchResponse 

type VcApplyPatchResponse struct {
	Applied bool `json:"applied" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Applied     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

VCS patch applied

func (VcApplyPatchResponse) RawJSON 

func (r VcApplyPatchResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*VcApplyPatchResponse) UnmarshalJSON 

func (r *VcApplyPatchResponse) UnmarshalJSON(data []byte) error

type VcDiffGetParams 

type VcDiffGetParams struct {
	// Any of "git", "branch".
	Mode      VcDiffGetParamsMode `query:"mode,omitzero" api:"required" json:"-"`
	Directory param.Opt[string]   `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string]   `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (VcDiffGetParams) URLQuery 

func (r VcDiffGetParams) URLQuery() (v url.Values, err error)

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

type VcDiffGetParamsMode 

type VcDiffGetParamsMode string
const (
	VcDiffGetParamsModeGit    VcDiffGetParamsMode = "git"
	VcDiffGetParamsModeBranch VcDiffGetParamsMode = "branch"
)

type VcDiffGetRawParams 

type VcDiffGetRawParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (VcDiffGetRawParams) URLQuery 

func (r VcDiffGetRawParams) URLQuery() (v url.Values, err error)

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

type VcDiffGetResponse 

type VcDiffGetResponse struct {
	Additions float64 `json:"additions" api:"required"`
	Deletions float64 `json:"deletions" api:"required"`
	File      string  `json:"file" api:"required"`
	Patch     string  `json:"patch"`
	// Any of "added", "deleted", "modified".
	Status VcDiffGetResponseStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Additions   respjson.Field
		Deletions   respjson.Field
		File        respjson.Field
		Patch       respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (VcDiffGetResponse) RawJSON 

func (r VcDiffGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*VcDiffGetResponse) UnmarshalJSON 

func (r *VcDiffGetResponse) UnmarshalJSON(data []byte) error

type VcDiffGetResponseStatus 

type VcDiffGetResponseStatus string
const (
	VcDiffGetResponseStatusAdded    VcDiffGetResponseStatus = "added"
	VcDiffGetResponseStatusDeleted  VcDiffGetResponseStatus = "deleted"
	VcDiffGetResponseStatusModified VcDiffGetResponseStatus = "modified"
)

type VcDiffService 

type VcDiffService struct {
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

VcDiffService contains methods and other services that help with interacting with the opencode-stainless 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 NewVcDiffService method instead.

func NewVcDiffService 

func NewVcDiffService(opts ...option.RequestOption) (r VcDiffService)

NewVcDiffService 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 (*VcDiffService) Get 

func (r *VcDiffService) Get(ctx context.Context, query VcDiffGetParams, opts ...option.RequestOption) (res *[]VcDiffGetResponse, err error)

Retrieve the current git diff for the working tree or against the default branch.

func (*VcDiffService) GetRaw 

func (r *VcDiffService) GetRaw(ctx context.Context, query VcDiffGetRawParams, opts ...option.RequestOption) (err error)

Retrieve a raw patch for current uncommitted changes.

type VcGetParams 

type VcGetParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (VcGetParams) URLQuery 

func (r VcGetParams) URLQuery() (v url.Values, err error)

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

type VcGetResponse 

type VcGetResponse struct {
	Branch        string `json:"branch"`
	DefaultBranch string `json:"default_branch"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Branch        respjson.Field
		DefaultBranch respjson.Field
		ExtraFields   map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (VcGetResponse) RawJSON 

func (r VcGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*VcGetResponse) UnmarshalJSON 

func (r *VcGetResponse) UnmarshalJSON(data []byte) error

type VcGetStatusParams 

type VcGetStatusParams struct {
	Directory param.Opt[string] `query:"directory,omitzero" json:"-"`
	Workspace param.Opt[string] `query:"workspace,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (VcGetStatusParams) URLQuery 

func (r VcGetStatusParams) URLQuery() (v url.Values, err error)

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

type VcGetStatusResponse 

type VcGetStatusResponse struct {
	Additions float64 `json:"additions" api:"required"`
	Deletions float64 `json:"deletions" api:"required"`
	File      string  `json:"file" api:"required"`
	// Any of "added", "deleted", "modified".
	Status VcGetStatusResponseStatus `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Additions   respjson.Field
		Deletions   respjson.Field
		File        respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (VcGetStatusResponse) RawJSON 

func (r VcGetStatusResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*VcGetStatusResponse) UnmarshalJSON 

func (r *VcGetStatusResponse) UnmarshalJSON(data []byte) error

type VcGetStatusResponseStatus 

type VcGetStatusResponseStatus string
const (
	VcGetStatusResponseStatusAdded    VcGetStatusResponseStatus = "added"
	VcGetStatusResponseStatusDeleted  VcGetStatusResponseStatus = "deleted"
	VcGetStatusResponseStatusModified VcGetStatusResponseStatus = "modified"
)

type VcService 

type VcService struct {

	// Experimental HttpApi instance read routes.
	Diff VcDiffService
	// contains filtered or unexported fields
}

Experimental HttpApi instance read routes.

VcService contains methods and other services that help with interacting with the opencode-stainless 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 NewVcService method instead.

func NewVcService 

func NewVcService(opts ...option.RequestOption) (r VcService)

NewVcService 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 (*VcService) ApplyPatch 

func (r *VcService) ApplyPatch(ctx context.Context, params VcApplyPatchParams, opts ...option.RequestOption) (res *VcApplyPatchResponse, err error)

Apply a raw patch to the current working tree.

func (*VcService) Get 

func (r *VcService) Get(ctx context.Context, query VcGetParams, opts ...option.RequestOption) (res *VcGetResponse, err error)

Retrieve version control system (VCS) information for the current project, such as git branch.

func (*VcService) GetStatus 

func (r *VcService) GetStatus(ctx context.Context, query VcGetStatusParams, opts ...option.RequestOption) (res *[]VcGetStatusResponse, err error)

Retrieve changed files in the current working tree without patches.

type Workspace 

type Workspace struct {
	ID        string                 `json:"id" api:"required"`
	Name      string                 `json:"name" api:"required"`
	ProjectID string                 `json:"projectID" api:"required"`
	TimeUsed  WorkspaceTimeUsedUnion `json:"timeUsed" api:"required"`
	Type      string                 `json:"type" api:"required"`
	Branch    string                 `json:"branch" api:"nullable"`
	Directory string                 `json:"directory" api:"nullable"`
	Extra     any                    `json:"extra" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Name        respjson.Field
		ProjectID   respjson.Field
		TimeUsed    respjson.Field
		Type        respjson.Field
		Branch      respjson.Field
		Directory   respjson.Field
		Extra       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (Workspace) RawJSON 

func (r Workspace) RawJSON() string

Returns the unmodified JSON received from the API

func (*Workspace) UnmarshalJSON 

func (r *Workspace) UnmarshalJSON(data []byte) error

type WorkspaceTimeUsedString 

type WorkspaceTimeUsedString string
const (
	WorkspaceTimeUsedStringNaN           WorkspaceTimeUsedString = "NaN"
	WorkspaceTimeUsedStringInfinity      WorkspaceTimeUsedString = "Infinity"
	WorkspaceTimeUsedStringMinusInfinity WorkspaceTimeUsedString = "-Infinity"
)

type WorkspaceTimeUsedUnion 

type WorkspaceTimeUsedUnion struct {
	// This field will be present if the value is a [float64] instead of an object.
	OfFloat float64 `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfWorkspaceTimeUsedString string `json:",inline"`
	JSON                      struct {
		OfFloat                   respjson.Field
		OfWorkspaceTimeUsedString respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

WorkspaceTimeUsedUnion contains all possible properties and values from [float64], [string].

Use the methods beginning with 'As' to cast the union to one of its variants.

If the underlying value is not a json object, one of the following properties will be valid: OfFloat OfWorkspaceTimeUsedString]

func (WorkspaceTimeUsedUnion) AsFloat 

func (u WorkspaceTimeUsedUnion) AsFloat() (v float64)

func (WorkspaceTimeUsedUnion) AsWorkspaceTimeUsedString 

func (u WorkspaceTimeUsedUnion) AsWorkspaceTimeUsedString() (v string)

func (WorkspaceTimeUsedUnion) RawJSON 

func (u WorkspaceTimeUsedUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*WorkspaceTimeUsedUnion) UnmarshalJSON 

func (r *WorkspaceTimeUsedUnion) UnmarshalJSON(data []byte) error

Source Files

View all Source files

Directories

Path Synopsis
apierror
apiform
apijson
apiquery
encoding/json
Package json implements encoding and decoding of JSON as defined in RFC 7159.
 Package json implements encoding and decoding of JSON as defined in RFC 7159.
encoding/json/sentinel
encoding/json/shims
This package provides shims over Go 1.2{2,3} APIs which are missing from Go 1.22, and used by the Go 1.24 encoding/json package.
 This package provides shims over Go 1.2{2,3} APIs which are missing from Go 1.22, and used by the Go 1.24 encoding/json package.
paramutil
requestconfig
testutil
packages
param
respjson
ssestream
shared
constant

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.