openlayer

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

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

 Go to latest Published: Jan 2, 2025 License: Apache-2.0 Imports: 17 Imported by: 0

README

Openlayer Go API Library

Go Reference

The Openlayer Go library provides convenient access to the Openlayer REST API from applications written in Go. The full API of this library can be found in api.md.

It is generated with Stainless.

Installation

import (
	"github.com/openlayer-ai/openlayer-go" // imported as openlayer
)

Or to pin the version:

go get -u 'github.com/openlayer-ai/openlayer-go@v0.1.0-alpha.13'

Requirements

This library requires Go 1.18+.

Usage

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

package main

import (
	"context"
	"fmt"

	"github.com/openlayer-ai/openlayer-go"
	"github.com/openlayer-ai/openlayer-go/option"
)

func main() {
	client := openlayer.NewClient(
		option.WithAPIKey("My API Key"), // defaults to os.LookupEnv("OPENLAYER_API_KEY")
	)
	response, err := client.InferencePipelines.Data.Stream(
		context.TODO(),
		"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
		openlayer.InferencePipelineDataStreamParams{
			Config: openlayer.F[openlayer.InferencePipelineDataStreamParamsConfigUnion](openlayer.InferencePipelineDataStreamParamsConfigLlmData{
				InputVariableNames:   openlayer.F([]string{"user_query"}),
				OutputColumnName:     openlayer.F("output"),
				NumOfTokenColumnName: openlayer.F("tokens"),
				CostColumnName:       openlayer.F("cost"),
				TimestampColumnName:  openlayer.F("timestamp"),
			}),
			Rows: openlayer.F([]map[string]interface{}{{
				"user_query": "what is the meaning of life?",
				"output":     "42",
				"tokens":     map[string]interface{}{},
				"cost":       map[string]interface{}{},
				"timestamp":  map[string]interface{}{},
			}}),
		},
	)
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", response.Success)
}
Request fields

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

See the full list of request options.

Pagination

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

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

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

Errors

When the API returns a non-success status code, we return an error with type *openlayer.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.InferencePipelines.Data.Stream(
	context.TODO(),
	"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
	openlayer.InferencePipelineDataStreamParams{
		Config: openlayer.F[openlayer.InferencePipelineDataStreamParamsConfigUnion](openlayer.InferencePipelineDataStreamParamsConfigLlmData{
			InputVariableNames:   openlayer.F([]string{"user_query"}),
			OutputColumnName:     openlayer.F("output"),
			NumOfTokenColumnName: openlayer.F("tokens"),
			CostColumnName:       openlayer.F("cost"),
			TimestampColumnName:  openlayer.F("timestamp"),
		}),
		Rows: openlayer.F([]map[string]interface{}{{
			"user_query": "what is the meaning of life?",
			"output":     "42",
			"tokens":     map[string]interface{}{},
			"cost":       map[string]interface{}{},
			"timestamp":  map[string]interface{}{},
		}}),
	},
)
if err != nil {
	var apierr *openlayer.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 "/inference-pipelines/{inferencePipelineId}/data-stream": 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.InferencePipelines.Data.Stream(
	ctx,
	"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
	openlayer.InferencePipelineDataStreamParams{
		Config: openlayer.F[openlayer.InferencePipelineDataStreamParamsConfigUnion](openlayer.InferencePipelineDataStreamParamsConfigLlmData{
			InputVariableNames:   openlayer.F([]string{"user_query"}),
			OutputColumnName:     openlayer.F("output"),
			NumOfTokenColumnName: openlayer.F("tokens"),
			CostColumnName:       openlayer.F("cost"),
			TimestampColumnName:  openlayer.F("timestamp"),
		}),
		Rows: openlayer.F([]map[string]interface{}{{
			"user_query": "what is the meaning of life?",
			"output":     "42",
			"tokens":     map[string]interface{}{},
			"cost":       map[string]interface{}{},
			"timestamp":  map[string]interface{}{},
		}}),
	},
	// This sets the per-retry timeout
	option.WithRequestTimeout(20*time.Second),
)
File uploads

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

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

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

Retries

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

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

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

// Override per-request:
client.InferencePipelines.Data.Stream(
	context.TODO(),
	"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
	openlayer.InferencePipelineDataStreamParams{
		Config: openlayer.F[openlayer.InferencePipelineDataStreamParamsConfigUnion](openlayer.InferencePipelineDataStreamParamsConfigLlmData{
			InputVariableNames:   openlayer.F([]string{"user_query"}),
			OutputColumnName:     openlayer.F("output"),
			NumOfTokenColumnName: openlayer.F("tokens"),
			CostColumnName:       openlayer.F("cost"),
			TimestampColumnName:  openlayer.F("timestamp"),
		}),
		Rows: openlayer.F([]map[string]interface{}{{
			"user_query": "what is the meaning of life?",
			"output":     "42",
			"tokens":     map[string]interface{}{},
			"cost":       map[string]interface{}{},
			"timestamp":  map[string]interface{}{},
		}}),
	},
	option.WithMaxRetries(5),
)
Making custom/undocumented requests

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

Undocumented endpoints

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

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

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

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

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

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

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

Middleware

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

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

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

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

    return res, err
}

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

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

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

Semantic versioning

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

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

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

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

Contributing

See the contributing documentation.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Bool 

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

Bool is a param field helper which helps specify bools.

func F 

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

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

func FileParam 

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

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

func Float 

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

Float is a param field helper which helps specify floats.

func Int 

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

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

func Null 

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

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

func Raw 

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

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

func String 

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

String is a param field helper which helps specify strings.

Types

type Client 

type Client struct {
	Options            []option.RequestOption
	Projects           *ProjectService
	Commits            *CommitService
	InferencePipelines *InferencePipelineService
	Storage            *StorageService
}

Client creates a struct with services and top level methods that help with interacting with the openlayer 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 (OPENLAYER_API_KEY). The option passed in as arguments are applied after these default arguments, and all option will be passed down to the services and requests that this client makes.

func (*Client) Delete 

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

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

func (*Client) Execute 

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

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

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

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

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

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

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

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

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

func (*Client) Get 

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

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

func (*Client) Patch 

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

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

func (*Client) Post 

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

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

func (*Client) Put 

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

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

type CommitService 

type CommitService struct {
	Options     []option.RequestOption
	TestResults *CommitTestResultService
}

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

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

func NewCommitService 

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

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

type CommitTestResultListParams 

type CommitTestResultListParams struct {
	// Include archived goals.
	IncludeArchived param.Field[bool] `query:"includeArchived"`
	// The page to return in a paginated query.
	Page param.Field[int64] `query:"page"`
	// Maximum number of items to return per page.
	PerPage param.Field[int64] `query:"perPage"`
	// Filter list of test results by status. Available statuses are `running`,
	// `passing`, `failing`, `skipped`, and `error`.
	Status param.Field[CommitTestResultListParamsStatus] `query:"status"`
	// Filter objects by test type. Available types are `integrity`, `consistency`,
	// `performance`, `fairness`, and `robustness`.
	Type param.Field[CommitTestResultListParamsType] `query:"type"`
}

func (CommitTestResultListParams) URLQuery 

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

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

type CommitTestResultListParamsStatus 

type CommitTestResultListParamsStatus string

Filter list of test results by status. Available statuses are `running`, `passing`, `failing`, `skipped`, and `error`. 

const (
	CommitTestResultListParamsStatusRunning CommitTestResultListParamsStatus = "running"
	CommitTestResultListParamsStatusPassing CommitTestResultListParamsStatus = "passing"
	CommitTestResultListParamsStatusFailing CommitTestResultListParamsStatus = "failing"
	CommitTestResultListParamsStatusSkipped CommitTestResultListParamsStatus = "skipped"
	CommitTestResultListParamsStatusError   CommitTestResultListParamsStatus = "error"
)

func (CommitTestResultListParamsStatus) IsKnown 

func (r CommitTestResultListParamsStatus) IsKnown() bool

type CommitTestResultListParamsType 

type CommitTestResultListParamsType string

Filter objects by test type. Available types are `integrity`, `consistency`, `performance`, `fairness`, and `robustness`. 

const (
	CommitTestResultListParamsTypeIntegrity   CommitTestResultListParamsType = "integrity"
	CommitTestResultListParamsTypeConsistency CommitTestResultListParamsType = "consistency"
	CommitTestResultListParamsTypePerformance CommitTestResultListParamsType = "performance"
	CommitTestResultListParamsTypeFairness    CommitTestResultListParamsType = "fairness"
	CommitTestResultListParamsTypeRobustness  CommitTestResultListParamsType = "robustness"
)

func (CommitTestResultListParamsType) IsKnown 

func (r CommitTestResultListParamsType) IsKnown() bool

type CommitTestResultListResponse 

type CommitTestResultListResponse struct {
	Items []CommitTestResultListResponseItem `json:"items,required"`
	JSON  commitTestResultListResponseJSON   `json:"-"`
}

func (*CommitTestResultListResponse) UnmarshalJSON 

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

type CommitTestResultListResponseItem 

type CommitTestResultListResponseItem struct {
	// Project version (commit) id.
	ID string `json:"id,required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The data end date.
	DateDataEnds time.Time `json:"dateDataEnds,required,nullable" format:"date-time"`
	// The data start date.
	DateDataStarts time.Time `json:"dateDataStarts,required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The inference pipeline id.
	InferencePipelineID string `json:"inferencePipelineId,required,nullable" format:"uuid"`
	// The project version (commit) id.
	ProjectVersionID string `json:"projectVersionId,required,nullable" format:"uuid"`
	// The status of the test.
	Status CommitTestResultListResponseItemsStatus `json:"status,required"`
	// The status message.
	StatusMessage string                                `json:"statusMessage,required,nullable"`
	Goal          CommitTestResultListResponseItemsGoal `json:"goal"`
	// The test id.
	GoalID string                               `json:"goalId,nullable" format:"uuid"`
	JSON   commitTestResultListResponseItemJSON `json:"-"`
}

func (*CommitTestResultListResponseItem) UnmarshalJSON 

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

type CommitTestResultListResponseItemsGoal 

type CommitTestResultListResponseItemsGoal struct {
	// The test id.
	ID string `json:"id,required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount,required"`
	// The test creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived,required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description,required,nullable"`
	// The test name.
	Name string `json:"name,required"`
	// The test number.
	Number int64 `json:"number,required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId,required,nullable" format:"uuid"`
	// The test subtype.
	Subtype string `json:"subtype,required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                             `json:"suggested,required"`
	Thresholds []CommitTestResultListResponseItemsGoalThreshold `json:"thresholds,required"`
	// The test type.
	Type string `json:"type,required"`
	// Whether the test is archived.
	Archived bool `json:"archived"`
	// The delay window in seconds. Only applies to tests that use production data.
	DelayWindow float64 `json:"delayWindow,nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow,nullable"`
	// Whether the test uses an ML model.
	UsesMlModel bool `json:"usesMlModel"`
	// Whether the test uses production data (monitoring mode only).
	UsesProductionData bool `json:"usesProductionData"`
	// Whether the test uses a reference dataset (monitoring mode only).
	UsesReferenceDataset bool `json:"usesReferenceDataset"`
	// Whether the test uses a training dataset.
	UsesTrainingDataset bool `json:"usesTrainingDataset"`
	// Whether the test uses a validation dataset.
	UsesValidationDataset bool                                      `json:"usesValidationDataset"`
	JSON                  commitTestResultListResponseItemsGoalJSON `json:"-"`
}

func (*CommitTestResultListResponseItemsGoal) UnmarshalJSON 

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

type CommitTestResultListResponseItemsGoalThreshold 

type CommitTestResultListResponseItemsGoalThreshold struct {
	// The insight name to be evaluated.
	InsightName       string        `json:"insightName"`
	InsightParameters []interface{} `json:"insightParameters"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator string `json:"operator"`
	// The value to be compared.
	Value CommitTestResultListResponseItemsGoalThresholdsValueUnion `json:"value"`
	JSON  commitTestResultListResponseItemsGoalThresholdJSON        `json:"-"`
}

func (*CommitTestResultListResponseItemsGoalThreshold) UnmarshalJSON 

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

type CommitTestResultListResponseItemsGoalThresholdsValueArray 

type CommitTestResultListResponseItemsGoalThresholdsValueArray []string

func (CommitTestResultListResponseItemsGoalThresholdsValueArray) ImplementsCommitTestResultListResponseItemsGoalThresholdsValueUnion 

func (r CommitTestResultListResponseItemsGoalThresholdsValueArray) ImplementsCommitTestResultListResponseItemsGoalThresholdsValueUnion()

type CommitTestResultListResponseItemsGoalThresholdsValueUnion 

type CommitTestResultListResponseItemsGoalThresholdsValueUnion interface {
	ImplementsCommitTestResultListResponseItemsGoalThresholdsValueUnion()
}

The value to be compared.

Union satisfied by shared.UnionFloat, shared.UnionBool, shared.UnionString or CommitTestResultListResponseItemsGoalThresholdsValueArray.

type CommitTestResultListResponseItemsStatus 

type CommitTestResultListResponseItemsStatus string

The status of the test. 

const (
	CommitTestResultListResponseItemsStatusRunning CommitTestResultListResponseItemsStatus = "running"
	CommitTestResultListResponseItemsStatusPassing CommitTestResultListResponseItemsStatus = "passing"
	CommitTestResultListResponseItemsStatusFailing CommitTestResultListResponseItemsStatus = "failing"
	CommitTestResultListResponseItemsStatusSkipped CommitTestResultListResponseItemsStatus = "skipped"
	CommitTestResultListResponseItemsStatusError   CommitTestResultListResponseItemsStatus = "error"
)

func (CommitTestResultListResponseItemsStatus) IsKnown 

func (r CommitTestResultListResponseItemsStatus) IsKnown() bool

type CommitTestResultService 

type CommitTestResultService struct {
	Options []option.RequestOption
}

CommitTestResultService contains methods and other services that help with interacting with the openlayer 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 NewCommitTestResultService method instead.

func NewCommitTestResultService 

func NewCommitTestResultService(opts ...option.RequestOption) (r *CommitTestResultService)

NewCommitTestResultService 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 (*CommitTestResultService) List 

func (r *CommitTestResultService) List(ctx context.Context, projectVersionID string, query CommitTestResultListParams, opts ...option.RequestOption) (res *CommitTestResultListResponse, err error)

List the test results for a project commit (project version).

type Error 

type Error = apierror.Error

type InferencePipelineDataService 

type InferencePipelineDataService struct {
	Options []option.RequestOption
}

InferencePipelineDataService contains methods and other services that help with interacting with the openlayer 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 NewInferencePipelineDataService method instead.

func NewInferencePipelineDataService 

func NewInferencePipelineDataService(opts ...option.RequestOption) (r *InferencePipelineDataService)

NewInferencePipelineDataService 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 (*InferencePipelineDataService) Stream 

func (r *InferencePipelineDataService) Stream(ctx context.Context, inferencePipelineID string, body InferencePipelineDataStreamParams, opts ...option.RequestOption) (res *InferencePipelineDataStreamResponse, err error)

Publish an inference data point to an inference pipeline.

type InferencePipelineDataStreamParams 

type InferencePipelineDataStreamParams struct {
	// Configuration for the data stream. Depends on your **Openlayer project task
	// type**.
	Config param.Field[InferencePipelineDataStreamParamsConfigUnion] `json:"config,required"`
	// A list of inference data points with inputs and outputs
	Rows param.Field[[]map[string]interface{}] `json:"rows,required"`
}

func (InferencePipelineDataStreamParams) MarshalJSON 

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

type InferencePipelineDataStreamParamsConfig 

type InferencePipelineDataStreamParamsConfig struct {
	CategoricalFeatureNames param.Field[interface{}] `json:"categoricalFeatureNames"`
	ClassNames              param.Field[interface{}] `json:"classNames"`
	// Name of the column with the context retrieved. Applies to RAG use cases.
	// Providing the context enables RAG-specific metrics.
	ContextColumnName param.Field[string] `json:"contextColumnName"`
	// Name of the column with the cost associated with each row.
	CostColumnName param.Field[string]      `json:"costColumnName"`
	FeatureNames   param.Field[interface{}] `json:"featureNames"`
	// Name of the column with the ground truths.
	GroundTruthColumnName param.Field[string] `json:"groundTruthColumnName"`
	// Name of the column with the inference ids. This is useful if you want to update
	// rows at a later point in time. If not provided, a unique id is generated by
	// Openlayer.
	InferenceIDColumnName param.Field[string]      `json:"inferenceIdColumnName"`
	InputVariableNames    param.Field[interface{}] `json:"inputVariableNames"`
	// Name of the column with the labels. The data in this column must be
	// **zero-indexed integers**, matching the list provided in `classNames`.
	LabelColumnName param.Field[string] `json:"labelColumnName"`
	// Name of the column with the latencies.
	LatencyColumnName param.Field[string]      `json:"latencyColumnName"`
	Metadata          param.Field[interface{}] `json:"metadata"`
	// Name of the column with the total number of tokens.
	NumOfTokenColumnName param.Field[string] `json:"numOfTokenColumnName"`
	// Name of the column with the model outputs.
	OutputColumnName param.Field[string] `json:"outputColumnName"`
	// Name of the column with the model's predictions as **zero-indexed integers**.
	PredictionsColumnName param.Field[string] `json:"predictionsColumnName"`
	// Name of the column with the model's predictions as **lists of class
	// probabilities**.
	PredictionScoresColumnName param.Field[string]      `json:"predictionScoresColumnName"`
	Prompt                     param.Field[interface{}] `json:"prompt"`
	// Name of the column with the questions. Applies to RAG use cases. Providing the
	// question enables RAG-specific metrics.
	QuestionColumnName param.Field[string] `json:"questionColumnName"`
	// Name of the column with the targets (ground truth values).
	TargetColumnName param.Field[string] `json:"targetColumnName"`
	// Name of the column with the text data.
	TextColumnName param.Field[string] `json:"textColumnName"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName param.Field[string] `json:"timestampColumnName"`
}

Configuration for the data stream. Depends on your **Openlayer project task type**.

func (InferencePipelineDataStreamParamsConfig) MarshalJSON 

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

type InferencePipelineDataStreamParamsConfigLlmData 

type InferencePipelineDataStreamParamsConfigLlmData struct {
	// Name of the column with the model outputs.
	OutputColumnName param.Field[string] `json:"outputColumnName,required"`
	// Name of the column with the context retrieved. Applies to RAG use cases.
	// Providing the context enables RAG-specific metrics.
	ContextColumnName param.Field[string] `json:"contextColumnName"`
	// Name of the column with the cost associated with each row.
	CostColumnName param.Field[string] `json:"costColumnName"`
	// Name of the column with the ground truths.
	GroundTruthColumnName param.Field[string] `json:"groundTruthColumnName"`
	// Name of the column with the inference ids. This is useful if you want to update
	// rows at a later point in time. If not provided, a unique id is generated by
	// Openlayer.
	InferenceIDColumnName param.Field[string] `json:"inferenceIdColumnName"`
	// Array of input variable names. Each input variable should be a dataset column.
	InputVariableNames param.Field[[]string] `json:"inputVariableNames"`
	// Name of the column with the latencies.
	LatencyColumnName param.Field[string] `json:"latencyColumnName"`
	// Object with metadata.
	Metadata param.Field[interface{}] `json:"metadata"`
	// Name of the column with the total number of tokens.
	NumOfTokenColumnName param.Field[string] `json:"numOfTokenColumnName"`
	// Prompt for the LLM.
	Prompt param.Field[[]InferencePipelineDataStreamParamsConfigLlmDataPrompt] `json:"prompt"`
	// Name of the column with the questions. Applies to RAG use cases. Providing the
	// question enables RAG-specific metrics.
	QuestionColumnName param.Field[string] `json:"questionColumnName"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName param.Field[string] `json:"timestampColumnName"`
}

func (InferencePipelineDataStreamParamsConfigLlmData) MarshalJSON 

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

type InferencePipelineDataStreamParamsConfigLlmDataPrompt 

type InferencePipelineDataStreamParamsConfigLlmDataPrompt struct {
	// Content of the prompt.
	Content param.Field[string] `json:"content"`
	// Role of the prompt.
	Role param.Field[string] `json:"role"`
}

func (InferencePipelineDataStreamParamsConfigLlmDataPrompt) MarshalJSON 

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

type InferencePipelineDataStreamParamsConfigTabularClassificationData 

type InferencePipelineDataStreamParamsConfigTabularClassificationData struct {
	// List of class names indexed by label integer in the dataset. E.g. ["Retained",
	// "Exited"] when 0, 1 are in your label column.
	ClassNames param.Field[[]string] `json:"classNames,required"`
	// Array with the names of all categorical features in the dataset. E.g. ["Age",
	// "Geography"].
	CategoricalFeatureNames param.Field[[]string] `json:"categoricalFeatureNames"`
	// Array with all input feature names.
	FeatureNames param.Field[[]string] `json:"featureNames"`
	// Name of the column with the inference ids. This is useful if you want to update
	// rows at a later point in time. If not provided, a unique id is generated by
	// Openlayer.
	InferenceIDColumnName param.Field[string] `json:"inferenceIdColumnName"`
	// Name of the column with the labels. The data in this column must be
	// **zero-indexed integers**, matching the list provided in `classNames`.
	LabelColumnName param.Field[string] `json:"labelColumnName"`
	// Name of the column with the latencies.
	LatencyColumnName param.Field[string] `json:"latencyColumnName"`
	// Object with metadata.
	Metadata param.Field[interface{}] `json:"metadata"`
	// Name of the column with the model's predictions as **zero-indexed integers**.
	PredictionsColumnName param.Field[string] `json:"predictionsColumnName"`
	// Name of the column with the model's predictions as **lists of class
	// probabilities**.
	PredictionScoresColumnName param.Field[string] `json:"predictionScoresColumnName"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName param.Field[string] `json:"timestampColumnName"`
}

func (InferencePipelineDataStreamParamsConfigTabularClassificationData) MarshalJSON 

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

type InferencePipelineDataStreamParamsConfigTabularRegressionData 

type InferencePipelineDataStreamParamsConfigTabularRegressionData struct {
	// Array with the names of all categorical features in the dataset. E.g. ["Gender",
	// "Geography"].
	CategoricalFeatureNames param.Field[[]string] `json:"categoricalFeatureNames"`
	// Array with all input feature names.
	FeatureNames param.Field[[]string] `json:"featureNames"`
	// Name of the column with the inference ids. This is useful if you want to update
	// rows at a later point in time. If not provided, a unique id is generated by
	// Openlayer.
	InferenceIDColumnName param.Field[string] `json:"inferenceIdColumnName"`
	// Name of the column with the latencies.
	LatencyColumnName param.Field[string] `json:"latencyColumnName"`
	// Object with metadata.
	Metadata param.Field[interface{}] `json:"metadata"`
	// Name of the column with the model's predictions.
	PredictionsColumnName param.Field[string] `json:"predictionsColumnName"`
	// Name of the column with the targets (ground truth values).
	TargetColumnName param.Field[string] `json:"targetColumnName"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName param.Field[string] `json:"timestampColumnName"`
}

func (InferencePipelineDataStreamParamsConfigTabularRegressionData) MarshalJSON 

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

type InferencePipelineDataStreamParamsConfigTextClassificationData 

type InferencePipelineDataStreamParamsConfigTextClassificationData struct {
	// List of class names indexed by label integer in the dataset. E.g. ["Retained",
	// "Exited"] when 0, 1 are in your label column.
	ClassNames param.Field[[]string] `json:"classNames,required"`
	// Name of the column with the inference ids. This is useful if you want to update
	// rows at a later point in time. If not provided, a unique id is generated by
	// Openlayer.
	InferenceIDColumnName param.Field[string] `json:"inferenceIdColumnName"`
	// Name of the column with the labels. The data in this column must be
	// **zero-indexed integers**, matching the list provided in `classNames`.
	LabelColumnName param.Field[string] `json:"labelColumnName"`
	// Name of the column with the latencies.
	LatencyColumnName param.Field[string] `json:"latencyColumnName"`
	// Object with metadata.
	Metadata param.Field[interface{}] `json:"metadata"`
	// Name of the column with the model's predictions as **zero-indexed integers**.
	PredictionsColumnName param.Field[string] `json:"predictionsColumnName"`
	// Name of the column with the model's predictions as **lists of class
	// probabilities**.
	PredictionScoresColumnName param.Field[string] `json:"predictionScoresColumnName"`
	// Name of the column with the text data.
	TextColumnName param.Field[string] `json:"textColumnName"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName param.Field[string] `json:"timestampColumnName"`
}

func (InferencePipelineDataStreamParamsConfigTextClassificationData) MarshalJSON 

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

type InferencePipelineDataStreamParamsConfigUnion 

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

Configuration for the data stream. Depends on your **Openlayer project task type**.

Satisfied by InferencePipelineDataStreamParamsConfigLlmData, InferencePipelineDataStreamParamsConfigTabularClassificationData, InferencePipelineDataStreamParamsConfigTabularRegressionData, InferencePipelineDataStreamParamsConfigTextClassificationData, InferencePipelineDataStreamParamsConfig.

type InferencePipelineDataStreamResponse 

type InferencePipelineDataStreamResponse struct {
	Success InferencePipelineDataStreamResponseSuccess `json:"success,required"`
	JSON    inferencePipelineDataStreamResponseJSON    `json:"-"`
}

func (*InferencePipelineDataStreamResponse) UnmarshalJSON 

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

type InferencePipelineDataStreamResponseSuccess 

type InferencePipelineDataStreamResponseSuccess bool
const (
	InferencePipelineDataStreamResponseSuccessTrue InferencePipelineDataStreamResponseSuccess = true
)

func (InferencePipelineDataStreamResponseSuccess) IsKnown 

func (r InferencePipelineDataStreamResponseSuccess) IsKnown() bool

type InferencePipelineGetParams 

type InferencePipelineGetParams struct {
	// Expand specific nested objects.
	Expand param.Field[[]InferencePipelineGetParamsExpand] `query:"expand"`
}

func (InferencePipelineGetParams) URLQuery 

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

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

type InferencePipelineGetParamsExpand 

type InferencePipelineGetParamsExpand string
const (
	InferencePipelineGetParamsExpandProject   InferencePipelineGetParamsExpand = "project"
	InferencePipelineGetParamsExpandWorkspace InferencePipelineGetParamsExpand = "workspace"
)

func (InferencePipelineGetParamsExpand) IsKnown 

func (r InferencePipelineGetParamsExpand) IsKnown() bool

type InferencePipelineGetResponse 

type InferencePipelineGetResponse struct {
	// The inference pipeline id.
	ID string `json:"id,required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated,required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived,required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation,required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description,required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                             `json:"failingGoalCount,required"`
	Links            InferencePipelineGetResponseLinks `json:"links,required"`
	// The inference pipeline name.
	Name string `json:"name,required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount,required"`
	// The project id.
	ProjectID string `json:"projectId,required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status InferencePipelineGetResponseStatus `json:"status,required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage,required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                 `json:"totalGoalCount,required"`
	Project        InferencePipelineGetResponseProject   `json:"project,nullable"`
	Workspace      InferencePipelineGetResponseWorkspace `json:"workspace,nullable"`
	// The workspace id.
	WorkspaceID string                           `json:"workspaceId" format:"uuid"`
	JSON        inferencePipelineGetResponseJSON `json:"-"`
}

func (*InferencePipelineGetResponse) UnmarshalJSON 

func (r *InferencePipelineGetResponse) UnmarshalJSON(data []byte) (err error)
type InferencePipelineGetResponseLinks struct {
	App  string                                `json:"app,required"`
	JSON inferencePipelineGetResponseLinksJSON `json:"-"`
}

func (*InferencePipelineGetResponseLinks) UnmarshalJSON 

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

type InferencePipelineGetResponseProject 

type InferencePipelineGetResponseProject struct {
	// The project id.
	ID string `json:"id,required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount,required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount,required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount,required"`
	// Links to the project.
	Links InferencePipelineGetResponseProjectLinks `json:"links,required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount,required"`
	// The project name.
	Name string `json:"name,required"`
	// The source of the project.
	Source InferencePipelineGetResponseProjectSource `json:"source,required,nullable"`
	// The task type of the project.
	TaskType InferencePipelineGetResponseProjectTaskType `json:"taskType,required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount,required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId,required,nullable" format:"uuid"`
	// The project description.
	Description string                                     `json:"description,nullable"`
	GitRepo     InferencePipelineGetResponseProjectGitRepo `json:"gitRepo,nullable"`
	JSON        inferencePipelineGetResponseProjectJSON    `json:"-"`
}

func (*InferencePipelineGetResponseProject) UnmarshalJSON 

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

type InferencePipelineGetResponseProjectGitRepo 

type InferencePipelineGetResponseProjectGitRepo struct {
	ID            string                                         `json:"id,required" format:"uuid"`
	DateConnected time.Time                                      `json:"dateConnected,required" format:"date-time"`
	DateUpdated   time.Time                                      `json:"dateUpdated,required" format:"date-time"`
	GitAccountID  string                                         `json:"gitAccountId,required" format:"uuid"`
	GitID         int64                                          `json:"gitId,required"`
	Name          string                                         `json:"name,required"`
	Private       bool                                           `json:"private,required"`
	ProjectID     string                                         `json:"projectId,required" format:"uuid"`
	Slug          string                                         `json:"slug,required"`
	URL           string                                         `json:"url,required" format:"url"`
	Branch        string                                         `json:"branch"`
	RootDir       string                                         `json:"rootDir"`
	JSON          inferencePipelineGetResponseProjectGitRepoJSON `json:"-"`
}

func (*InferencePipelineGetResponseProjectGitRepo) UnmarshalJSON 

func (r *InferencePipelineGetResponseProjectGitRepo) UnmarshalJSON(data []byte) (err error)
type InferencePipelineGetResponseProjectLinks struct {
	App  string                                       `json:"app,required"`
	JSON inferencePipelineGetResponseProjectLinksJSON `json:"-"`
}

Links to the project.

func (*InferencePipelineGetResponseProjectLinks) UnmarshalJSON 

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

type InferencePipelineGetResponseProjectSource 

type InferencePipelineGetResponseProjectSource string

The source of the project. 

const (
	InferencePipelineGetResponseProjectSourceWeb  InferencePipelineGetResponseProjectSource = "web"
	InferencePipelineGetResponseProjectSourceAPI  InferencePipelineGetResponseProjectSource = "api"
	InferencePipelineGetResponseProjectSourceNull InferencePipelineGetResponseProjectSource = "null"
)

func (InferencePipelineGetResponseProjectSource) IsKnown 

func (r InferencePipelineGetResponseProjectSource) IsKnown() bool

type InferencePipelineGetResponseProjectTaskType 

type InferencePipelineGetResponseProjectTaskType string

The task type of the project. 

const (
	InferencePipelineGetResponseProjectTaskTypeLlmBase               InferencePipelineGetResponseProjectTaskType = "llm-base"
	InferencePipelineGetResponseProjectTaskTypeTabularClassification InferencePipelineGetResponseProjectTaskType = "tabular-classification"
	InferencePipelineGetResponseProjectTaskTypeTabularRegression     InferencePipelineGetResponseProjectTaskType = "tabular-regression"
	InferencePipelineGetResponseProjectTaskTypeTextClassification    InferencePipelineGetResponseProjectTaskType = "text-classification"
)

func (InferencePipelineGetResponseProjectTaskType) IsKnown 

func (r InferencePipelineGetResponseProjectTaskType) IsKnown() bool

type InferencePipelineGetResponseStatus 

type InferencePipelineGetResponseStatus string

The status of test evaluation for the inference pipeline. 

const (
	InferencePipelineGetResponseStatusQueued    InferencePipelineGetResponseStatus = "queued"
	InferencePipelineGetResponseStatusRunning   InferencePipelineGetResponseStatus = "running"
	InferencePipelineGetResponseStatusPaused    InferencePipelineGetResponseStatus = "paused"
	InferencePipelineGetResponseStatusFailed    InferencePipelineGetResponseStatus = "failed"
	InferencePipelineGetResponseStatusCompleted InferencePipelineGetResponseStatus = "completed"
	InferencePipelineGetResponseStatusUnknown   InferencePipelineGetResponseStatus = "unknown"
)

func (InferencePipelineGetResponseStatus) IsKnown 

func (r InferencePipelineGetResponseStatus) IsKnown() bool

type InferencePipelineGetResponseWorkspace 

type InferencePipelineGetResponseWorkspace struct {
	ID              string                                              `json:"id,required" format:"uuid"`
	CreatorID       string                                              `json:"creatorId,required,nullable" format:"uuid"`
	DateCreated     time.Time                                           `json:"dateCreated,required" format:"date-time"`
	DateUpdated     time.Time                                           `json:"dateUpdated,required" format:"date-time"`
	InviteCount     int64                                               `json:"inviteCount,required"`
	MemberCount     int64                                               `json:"memberCount,required"`
	Name            string                                              `json:"name,required"`
	PeriodEndDate   time.Time                                           `json:"periodEndDate,required,nullable" format:"date-time"`
	PeriodStartDate time.Time                                           `json:"periodStartDate,required,nullable" format:"date-time"`
	ProjectCount    int64                                               `json:"projectCount,required"`
	Slug            string                                              `json:"slug,required"`
	Status          InferencePipelineGetResponseWorkspaceStatus         `json:"status,required"`
	MonthlyUsage    []InferencePipelineGetResponseWorkspaceMonthlyUsage `json:"monthlyUsage"`
	SAMLOnlyAccess  bool                                                `json:"samlOnlyAccess"`
	WildcardDomains []string                                            `json:"wildcardDomains"`
	JSON            inferencePipelineGetResponseWorkspaceJSON           `json:"-"`
}

func (*InferencePipelineGetResponseWorkspace) UnmarshalJSON 

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

type InferencePipelineGetResponseWorkspaceMonthlyUsage 

type InferencePipelineGetResponseWorkspaceMonthlyUsage struct {
	ExecutionTimeMs int64                                                 `json:"executionTimeMs,nullable"`
	MonthYear       time.Time                                             `json:"monthYear" format:"date"`
	PredictionCount int64                                                 `json:"predictionCount"`
	JSON            inferencePipelineGetResponseWorkspaceMonthlyUsageJSON `json:"-"`
}

func (*InferencePipelineGetResponseWorkspaceMonthlyUsage) UnmarshalJSON 

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

type InferencePipelineGetResponseWorkspaceStatus 

type InferencePipelineGetResponseWorkspaceStatus string
const (
	InferencePipelineGetResponseWorkspaceStatusActive            InferencePipelineGetResponseWorkspaceStatus = "active"
	InferencePipelineGetResponseWorkspaceStatusPastDue           InferencePipelineGetResponseWorkspaceStatus = "past_due"
	InferencePipelineGetResponseWorkspaceStatusUnpaid            InferencePipelineGetResponseWorkspaceStatus = "unpaid"
	InferencePipelineGetResponseWorkspaceStatusCanceled          InferencePipelineGetResponseWorkspaceStatus = "canceled"
	InferencePipelineGetResponseWorkspaceStatusIncomplete        InferencePipelineGetResponseWorkspaceStatus = "incomplete"
	InferencePipelineGetResponseWorkspaceStatusIncompleteExpired InferencePipelineGetResponseWorkspaceStatus = "incomplete_expired"
	InferencePipelineGetResponseWorkspaceStatusTrialing          InferencePipelineGetResponseWorkspaceStatus = "trialing"
	InferencePipelineGetResponseWorkspaceStatusPaused            InferencePipelineGetResponseWorkspaceStatus = "paused"
)

func (InferencePipelineGetResponseWorkspaceStatus) IsKnown 

func (r InferencePipelineGetResponseWorkspaceStatus) IsKnown() bool

type InferencePipelineRowService 

type InferencePipelineRowService struct {
	Options []option.RequestOption
}

InferencePipelineRowService contains methods and other services that help with interacting with the openlayer 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 NewInferencePipelineRowService method instead.

func NewInferencePipelineRowService 

func NewInferencePipelineRowService(opts ...option.RequestOption) (r *InferencePipelineRowService)

NewInferencePipelineRowService 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 (*InferencePipelineRowService) Update 

func (r *InferencePipelineRowService) Update(ctx context.Context, inferencePipelineID string, params InferencePipelineRowUpdateParams, opts ...option.RequestOption) (res *InferencePipelineRowUpdateResponse, err error)

Update an inference data point in an inference pipeline.

type InferencePipelineRowUpdateParams 

type InferencePipelineRowUpdateParams struct {
	// Specify the inference id as a query param.
	InferenceID param.Field[string]                                 `query:"inferenceId,required"`
	Row         param.Field[interface{}]                            `json:"row,required"`
	Config      param.Field[InferencePipelineRowUpdateParamsConfig] `json:"config"`
}

func (InferencePipelineRowUpdateParams) MarshalJSON 

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

func (InferencePipelineRowUpdateParams) URLQuery 

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

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

type InferencePipelineRowUpdateParamsConfig 

type InferencePipelineRowUpdateParamsConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName param.Field[string] `json:"groundTruthColumnName"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName param.Field[string] `json:"humanFeedbackColumnName"`
	// Name of the column with the inference ids. This is useful if you want to update
	// rows at a later point in time. If not provided, a unique id is generated by
	// Openlayer.
	InferenceIDColumnName param.Field[string] `json:"inferenceIdColumnName"`
	// Name of the column with the latencies.
	LatencyColumnName param.Field[string] `json:"latencyColumnName"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName param.Field[string] `json:"timestampColumnName"`
}

func (InferencePipelineRowUpdateParamsConfig) MarshalJSON 

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

type InferencePipelineRowUpdateResponse 

type InferencePipelineRowUpdateResponse struct {
	Success InferencePipelineRowUpdateResponseSuccess `json:"success,required"`
	JSON    inferencePipelineRowUpdateResponseJSON    `json:"-"`
}

func (*InferencePipelineRowUpdateResponse) UnmarshalJSON 

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

type InferencePipelineRowUpdateResponseSuccess 

type InferencePipelineRowUpdateResponseSuccess bool
const (
	InferencePipelineRowUpdateResponseSuccessTrue InferencePipelineRowUpdateResponseSuccess = true
)

func (InferencePipelineRowUpdateResponseSuccess) IsKnown 

func (r InferencePipelineRowUpdateResponseSuccess) IsKnown() bool

type InferencePipelineService 

type InferencePipelineService struct {
	Options     []option.RequestOption
	Data        *InferencePipelineDataService
	Rows        *InferencePipelineRowService
	TestResults *InferencePipelineTestResultService
}

InferencePipelineService contains methods and other services that help with interacting with the openlayer 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 NewInferencePipelineService method instead.

func NewInferencePipelineService 

func NewInferencePipelineService(opts ...option.RequestOption) (r *InferencePipelineService)

NewInferencePipelineService 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 (*InferencePipelineService) Delete 

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

Delete inference pipeline.

func (*InferencePipelineService) Get 

func (r *InferencePipelineService) Get(ctx context.Context, inferencePipelineID string, query InferencePipelineGetParams, opts ...option.RequestOption) (res *InferencePipelineGetResponse, err error)

Retrieve inference pipeline.

func (*InferencePipelineService) Update 

func (r *InferencePipelineService) Update(ctx context.Context, inferencePipelineID string, body InferencePipelineUpdateParams, opts ...option.RequestOption) (res *InferencePipelineUpdateResponse, err error)

Update inference pipeline.

type InferencePipelineTestResultListParams 

type InferencePipelineTestResultListParams struct {
	// The page to return in a paginated query.
	Page param.Field[int64] `query:"page"`
	// Maximum number of items to return per page.
	PerPage param.Field[int64] `query:"perPage"`
	// Filter list of test results by status. Available statuses are `running`,
	// `passing`, `failing`, `skipped`, and `error`.
	Status param.Field[InferencePipelineTestResultListParamsStatus] `query:"status"`
	// Filter objects by test type. Available types are `integrity`, `consistency`,
	// `performance`, `fairness`, and `robustness`.
	Type param.Field[InferencePipelineTestResultListParamsType] `query:"type"`
}

func (InferencePipelineTestResultListParams) URLQuery 

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

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

type InferencePipelineTestResultListParamsStatus 

type InferencePipelineTestResultListParamsStatus string

Filter list of test results by status. Available statuses are `running`, `passing`, `failing`, `skipped`, and `error`. 

const (
	InferencePipelineTestResultListParamsStatusRunning InferencePipelineTestResultListParamsStatus = "running"
	InferencePipelineTestResultListParamsStatusPassing InferencePipelineTestResultListParamsStatus = "passing"
	InferencePipelineTestResultListParamsStatusFailing InferencePipelineTestResultListParamsStatus = "failing"
	InferencePipelineTestResultListParamsStatusSkipped InferencePipelineTestResultListParamsStatus = "skipped"
	InferencePipelineTestResultListParamsStatusError   InferencePipelineTestResultListParamsStatus = "error"
)

func (InferencePipelineTestResultListParamsStatus) IsKnown 

func (r InferencePipelineTestResultListParamsStatus) IsKnown() bool

type InferencePipelineTestResultListParamsType 

type InferencePipelineTestResultListParamsType string

Filter objects by test type. Available types are `integrity`, `consistency`, `performance`, `fairness`, and `robustness`. 

const (
	InferencePipelineTestResultListParamsTypeIntegrity   InferencePipelineTestResultListParamsType = "integrity"
	InferencePipelineTestResultListParamsTypeConsistency InferencePipelineTestResultListParamsType = "consistency"
	InferencePipelineTestResultListParamsTypePerformance InferencePipelineTestResultListParamsType = "performance"
	InferencePipelineTestResultListParamsTypeFairness    InferencePipelineTestResultListParamsType = "fairness"
	InferencePipelineTestResultListParamsTypeRobustness  InferencePipelineTestResultListParamsType = "robustness"
)

func (InferencePipelineTestResultListParamsType) IsKnown 

func (r InferencePipelineTestResultListParamsType) IsKnown() bool

type InferencePipelineTestResultListResponse 

type InferencePipelineTestResultListResponse struct {
	Items []InferencePipelineTestResultListResponseItem `json:"items,required"`
	JSON  inferencePipelineTestResultListResponseJSON   `json:"-"`
}

func (*InferencePipelineTestResultListResponse) UnmarshalJSON 

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

type InferencePipelineTestResultListResponseItem 

type InferencePipelineTestResultListResponseItem struct {
	// Project version (commit) id.
	ID string `json:"id,required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The data end date.
	DateDataEnds time.Time `json:"dateDataEnds,required,nullable" format:"date-time"`
	// The data start date.
	DateDataStarts time.Time `json:"dateDataStarts,required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The inference pipeline id.
	InferencePipelineID string `json:"inferencePipelineId,required,nullable" format:"uuid"`
	// The project version (commit) id.
	ProjectVersionID string `json:"projectVersionId,required,nullable" format:"uuid"`
	// The status of the test.
	Status InferencePipelineTestResultListResponseItemsStatus `json:"status,required"`
	// The status message.
	StatusMessage string                                           `json:"statusMessage,required,nullable"`
	Goal          InferencePipelineTestResultListResponseItemsGoal `json:"goal"`
	// The test id.
	GoalID string                                          `json:"goalId,nullable" format:"uuid"`
	JSON   inferencePipelineTestResultListResponseItemJSON `json:"-"`
}

func (*InferencePipelineTestResultListResponseItem) UnmarshalJSON 

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

type InferencePipelineTestResultListResponseItemsGoal 

type InferencePipelineTestResultListResponseItemsGoal struct {
	// The test id.
	ID string `json:"id,required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount,required"`
	// The test creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived,required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description,required,nullable"`
	// The test name.
	Name string `json:"name,required"`
	// The test number.
	Number int64 `json:"number,required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId,required,nullable" format:"uuid"`
	// The test subtype.
	Subtype string `json:"subtype,required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                                        `json:"suggested,required"`
	Thresholds []InferencePipelineTestResultListResponseItemsGoalThreshold `json:"thresholds,required"`
	// The test type.
	Type string `json:"type,required"`
	// Whether the test is archived.
	Archived bool `json:"archived"`
	// The delay window in seconds. Only applies to tests that use production data.
	DelayWindow float64 `json:"delayWindow,nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow,nullable"`
	// Whether the test uses an ML model.
	UsesMlModel bool `json:"usesMlModel"`
	// Whether the test uses production data (monitoring mode only).
	UsesProductionData bool `json:"usesProductionData"`
	// Whether the test uses a reference dataset (monitoring mode only).
	UsesReferenceDataset bool `json:"usesReferenceDataset"`
	// Whether the test uses a training dataset.
	UsesTrainingDataset bool `json:"usesTrainingDataset"`
	// Whether the test uses a validation dataset.
	UsesValidationDataset bool                                                 `json:"usesValidationDataset"`
	JSON                  inferencePipelineTestResultListResponseItemsGoalJSON `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsGoal) UnmarshalJSON 

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

type InferencePipelineTestResultListResponseItemsGoalThreshold 

type InferencePipelineTestResultListResponseItemsGoalThreshold struct {
	// The insight name to be evaluated.
	InsightName       string        `json:"insightName"`
	InsightParameters []interface{} `json:"insightParameters"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator string `json:"operator"`
	// The value to be compared.
	Value InferencePipelineTestResultListResponseItemsGoalThresholdsValueUnion `json:"value"`
	JSON  inferencePipelineTestResultListResponseItemsGoalThresholdJSON        `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsGoalThreshold) UnmarshalJSON 

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

type InferencePipelineTestResultListResponseItemsGoalThresholdsValueArray 

type InferencePipelineTestResultListResponseItemsGoalThresholdsValueArray []string

func (InferencePipelineTestResultListResponseItemsGoalThresholdsValueArray) ImplementsInferencePipelineTestResultListResponseItemsGoalThresholdsValueUnion 

func (r InferencePipelineTestResultListResponseItemsGoalThresholdsValueArray) ImplementsInferencePipelineTestResultListResponseItemsGoalThresholdsValueUnion()

type InferencePipelineTestResultListResponseItemsGoalThresholdsValueUnion 

type InferencePipelineTestResultListResponseItemsGoalThresholdsValueUnion interface {
	ImplementsInferencePipelineTestResultListResponseItemsGoalThresholdsValueUnion()
}

The value to be compared.

Union satisfied by shared.UnionFloat, shared.UnionBool, shared.UnionString or InferencePipelineTestResultListResponseItemsGoalThresholdsValueArray.

type InferencePipelineTestResultListResponseItemsStatus 

type InferencePipelineTestResultListResponseItemsStatus string

The status of the test. 

const (
	InferencePipelineTestResultListResponseItemsStatusRunning InferencePipelineTestResultListResponseItemsStatus = "running"
	InferencePipelineTestResultListResponseItemsStatusPassing InferencePipelineTestResultListResponseItemsStatus = "passing"
	InferencePipelineTestResultListResponseItemsStatusFailing InferencePipelineTestResultListResponseItemsStatus = "failing"
	InferencePipelineTestResultListResponseItemsStatusSkipped InferencePipelineTestResultListResponseItemsStatus = "skipped"
	InferencePipelineTestResultListResponseItemsStatusError   InferencePipelineTestResultListResponseItemsStatus = "error"
)

func (InferencePipelineTestResultListResponseItemsStatus) IsKnown 

func (r InferencePipelineTestResultListResponseItemsStatus) IsKnown() bool

type InferencePipelineTestResultService 

type InferencePipelineTestResultService struct {
	Options []option.RequestOption
}

InferencePipelineTestResultService contains methods and other services that help with interacting with the openlayer 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 NewInferencePipelineTestResultService method instead.

func NewInferencePipelineTestResultService 

func NewInferencePipelineTestResultService(opts ...option.RequestOption) (r *InferencePipelineTestResultService)

NewInferencePipelineTestResultService 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 (*InferencePipelineTestResultService) List 

func (r *InferencePipelineTestResultService) List(ctx context.Context, inferencePipelineID string, query InferencePipelineTestResultListParams, opts ...option.RequestOption) (res *InferencePipelineTestResultListResponse, err error)

List the latest test results for an inference pipeline.

type InferencePipelineUpdateParams 

type InferencePipelineUpdateParams struct {
	// The inference pipeline description.
	Description param.Field[string] `json:"description"`
	// The inference pipeline name.
	Name param.Field[string] `json:"name"`
	// The storage uri of your reference dataset. We recommend using the Python SDK or
	// the UI to handle your reference dataset updates.
	ReferenceDatasetUri param.Field[string] `json:"referenceDatasetUri"`
}

func (InferencePipelineUpdateParams) MarshalJSON 

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

type InferencePipelineUpdateResponse 

type InferencePipelineUpdateResponse struct {
	// The inference pipeline id.
	ID string `json:"id,required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated,required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived,required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation,required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description,required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                                `json:"failingGoalCount,required"`
	Links            InferencePipelineUpdateResponseLinks `json:"links,required"`
	// The inference pipeline name.
	Name string `json:"name,required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount,required"`
	// The project id.
	ProjectID string `json:"projectId,required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status InferencePipelineUpdateResponseStatus `json:"status,required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage,required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                    `json:"totalGoalCount,required"`
	Project        InferencePipelineUpdateResponseProject   `json:"project,nullable"`
	Workspace      InferencePipelineUpdateResponseWorkspace `json:"workspace,nullable"`
	// The workspace id.
	WorkspaceID string                              `json:"workspaceId" format:"uuid"`
	JSON        inferencePipelineUpdateResponseJSON `json:"-"`
}

func (*InferencePipelineUpdateResponse) UnmarshalJSON 

func (r *InferencePipelineUpdateResponse) UnmarshalJSON(data []byte) (err error)
type InferencePipelineUpdateResponseLinks struct {
	App  string                                   `json:"app,required"`
	JSON inferencePipelineUpdateResponseLinksJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseLinks) UnmarshalJSON 

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

type InferencePipelineUpdateResponseProject 

type InferencePipelineUpdateResponseProject struct {
	// The project id.
	ID string `json:"id,required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount,required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount,required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount,required"`
	// Links to the project.
	Links InferencePipelineUpdateResponseProjectLinks `json:"links,required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount,required"`
	// The project name.
	Name string `json:"name,required"`
	// The source of the project.
	Source InferencePipelineUpdateResponseProjectSource `json:"source,required,nullable"`
	// The task type of the project.
	TaskType InferencePipelineUpdateResponseProjectTaskType `json:"taskType,required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount,required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId,required,nullable" format:"uuid"`
	// The project description.
	Description string                                        `json:"description,nullable"`
	GitRepo     InferencePipelineUpdateResponseProjectGitRepo `json:"gitRepo,nullable"`
	JSON        inferencePipelineUpdateResponseProjectJSON    `json:"-"`
}

func (*InferencePipelineUpdateResponseProject) UnmarshalJSON 

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

type InferencePipelineUpdateResponseProjectGitRepo 

type InferencePipelineUpdateResponseProjectGitRepo struct {
	ID            string                                            `json:"id,required" format:"uuid"`
	DateConnected time.Time                                         `json:"dateConnected,required" format:"date-time"`
	DateUpdated   time.Time                                         `json:"dateUpdated,required" format:"date-time"`
	GitAccountID  string                                            `json:"gitAccountId,required" format:"uuid"`
	GitID         int64                                             `json:"gitId,required"`
	Name          string                                            `json:"name,required"`
	Private       bool                                              `json:"private,required"`
	ProjectID     string                                            `json:"projectId,required" format:"uuid"`
	Slug          string                                            `json:"slug,required"`
	URL           string                                            `json:"url,required" format:"url"`
	Branch        string                                            `json:"branch"`
	RootDir       string                                            `json:"rootDir"`
	JSON          inferencePipelineUpdateResponseProjectGitRepoJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseProjectGitRepo) UnmarshalJSON 

func (r *InferencePipelineUpdateResponseProjectGitRepo) UnmarshalJSON(data []byte) (err error)
type InferencePipelineUpdateResponseProjectLinks struct {
	App  string                                          `json:"app,required"`
	JSON inferencePipelineUpdateResponseProjectLinksJSON `json:"-"`
}

Links to the project.

func (*InferencePipelineUpdateResponseProjectLinks) UnmarshalJSON 

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

type InferencePipelineUpdateResponseProjectSource 

type InferencePipelineUpdateResponseProjectSource string

The source of the project. 

const (
	InferencePipelineUpdateResponseProjectSourceWeb  InferencePipelineUpdateResponseProjectSource = "web"
	InferencePipelineUpdateResponseProjectSourceAPI  InferencePipelineUpdateResponseProjectSource = "api"
	InferencePipelineUpdateResponseProjectSourceNull InferencePipelineUpdateResponseProjectSource = "null"
)

func (InferencePipelineUpdateResponseProjectSource) IsKnown 

func (r InferencePipelineUpdateResponseProjectSource) IsKnown() bool

type InferencePipelineUpdateResponseProjectTaskType 

type InferencePipelineUpdateResponseProjectTaskType string

The task type of the project. 

const (
	InferencePipelineUpdateResponseProjectTaskTypeLlmBase               InferencePipelineUpdateResponseProjectTaskType = "llm-base"
	InferencePipelineUpdateResponseProjectTaskTypeTabularClassification InferencePipelineUpdateResponseProjectTaskType = "tabular-classification"
	InferencePipelineUpdateResponseProjectTaskTypeTabularRegression     InferencePipelineUpdateResponseProjectTaskType = "tabular-regression"
	InferencePipelineUpdateResponseProjectTaskTypeTextClassification    InferencePipelineUpdateResponseProjectTaskType = "text-classification"
)

func (InferencePipelineUpdateResponseProjectTaskType) IsKnown 

func (r InferencePipelineUpdateResponseProjectTaskType) IsKnown() bool

type InferencePipelineUpdateResponseStatus 

type InferencePipelineUpdateResponseStatus string

The status of test evaluation for the inference pipeline. 

const (
	InferencePipelineUpdateResponseStatusQueued    InferencePipelineUpdateResponseStatus = "queued"
	InferencePipelineUpdateResponseStatusRunning   InferencePipelineUpdateResponseStatus = "running"
	InferencePipelineUpdateResponseStatusPaused    InferencePipelineUpdateResponseStatus = "paused"
	InferencePipelineUpdateResponseStatusFailed    InferencePipelineUpdateResponseStatus = "failed"
	InferencePipelineUpdateResponseStatusCompleted InferencePipelineUpdateResponseStatus = "completed"
	InferencePipelineUpdateResponseStatusUnknown   InferencePipelineUpdateResponseStatus = "unknown"
)

func (InferencePipelineUpdateResponseStatus) IsKnown 

func (r InferencePipelineUpdateResponseStatus) IsKnown() bool

type InferencePipelineUpdateResponseWorkspace 

type InferencePipelineUpdateResponseWorkspace struct {
	ID              string                                                 `json:"id,required" format:"uuid"`
	CreatorID       string                                                 `json:"creatorId,required,nullable" format:"uuid"`
	DateCreated     time.Time                                              `json:"dateCreated,required" format:"date-time"`
	DateUpdated     time.Time                                              `json:"dateUpdated,required" format:"date-time"`
	InviteCount     int64                                                  `json:"inviteCount,required"`
	MemberCount     int64                                                  `json:"memberCount,required"`
	Name            string                                                 `json:"name,required"`
	PeriodEndDate   time.Time                                              `json:"periodEndDate,required,nullable" format:"date-time"`
	PeriodStartDate time.Time                                              `json:"periodStartDate,required,nullable" format:"date-time"`
	ProjectCount    int64                                                  `json:"projectCount,required"`
	Slug            string                                                 `json:"slug,required"`
	Status          InferencePipelineUpdateResponseWorkspaceStatus         `json:"status,required"`
	MonthlyUsage    []InferencePipelineUpdateResponseWorkspaceMonthlyUsage `json:"monthlyUsage"`
	SAMLOnlyAccess  bool                                                   `json:"samlOnlyAccess"`
	WildcardDomains []string                                               `json:"wildcardDomains"`
	JSON            inferencePipelineUpdateResponseWorkspaceJSON           `json:"-"`
}

func (*InferencePipelineUpdateResponseWorkspace) UnmarshalJSON 

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

type InferencePipelineUpdateResponseWorkspaceMonthlyUsage 

type InferencePipelineUpdateResponseWorkspaceMonthlyUsage struct {
	ExecutionTimeMs int64                                                    `json:"executionTimeMs,nullable"`
	MonthYear       time.Time                                                `json:"monthYear" format:"date"`
	PredictionCount int64                                                    `json:"predictionCount"`
	JSON            inferencePipelineUpdateResponseWorkspaceMonthlyUsageJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseWorkspaceMonthlyUsage) UnmarshalJSON 

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

type InferencePipelineUpdateResponseWorkspaceStatus 

type InferencePipelineUpdateResponseWorkspaceStatus string
const (
	InferencePipelineUpdateResponseWorkspaceStatusActive            InferencePipelineUpdateResponseWorkspaceStatus = "active"
	InferencePipelineUpdateResponseWorkspaceStatusPastDue           InferencePipelineUpdateResponseWorkspaceStatus = "past_due"
	InferencePipelineUpdateResponseWorkspaceStatusUnpaid            InferencePipelineUpdateResponseWorkspaceStatus = "unpaid"
	InferencePipelineUpdateResponseWorkspaceStatusCanceled          InferencePipelineUpdateResponseWorkspaceStatus = "canceled"
	InferencePipelineUpdateResponseWorkspaceStatusIncomplete        InferencePipelineUpdateResponseWorkspaceStatus = "incomplete"
	InferencePipelineUpdateResponseWorkspaceStatusIncompleteExpired InferencePipelineUpdateResponseWorkspaceStatus = "incomplete_expired"
	InferencePipelineUpdateResponseWorkspaceStatusTrialing          InferencePipelineUpdateResponseWorkspaceStatus = "trialing"
	InferencePipelineUpdateResponseWorkspaceStatusPaused            InferencePipelineUpdateResponseWorkspaceStatus = "paused"
)

func (InferencePipelineUpdateResponseWorkspaceStatus) IsKnown 

func (r InferencePipelineUpdateResponseWorkspaceStatus) IsKnown() bool

type ProjectCommitListParams 

type ProjectCommitListParams struct {
	// The page to return in a paginated query.
	Page param.Field[int64] `query:"page"`
	// Maximum number of items to return per page.
	PerPage param.Field[int64] `query:"perPage"`
}

func (ProjectCommitListParams) URLQuery 

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

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

type ProjectCommitListResponse 

type ProjectCommitListResponse struct {
	Items []ProjectCommitListResponseItem `json:"items,required"`
	JSON  projectCommitListResponseJSON   `json:"-"`
}

func (*ProjectCommitListResponse) UnmarshalJSON 

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

type ProjectCommitListResponseItem 

type ProjectCommitListResponseItem struct {
	// The project version (commit) id.
	ID string `json:"id,required" format:"uuid"`
	// The details of a commit (project version).
	Commit ProjectCommitListResponseItemsCommit `json:"commit,required"`
	// The commit archive date.
	DateArchived time.Time `json:"dateArchived,required,nullable" format:"date-time"`
	// The project version (commit) creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The number of tests that are failing for the commit.
	FailingGoalCount int64 `json:"failingGoalCount,required"`
	// The model id.
	MlModelID string `json:"mlModelId,required,nullable" format:"uuid"`
	// The number of tests that are passing for the commit.
	PassingGoalCount int64 `json:"passingGoalCount,required"`
	// The project id.
	ProjectID string `json:"projectId,required" format:"uuid"`
	// The commit status. Initially, the commit is `queued`, then, it switches to
	// `running`. Finally, it can be `paused`, `failed`, or `completed`.
	Status ProjectCommitListResponseItemsStatus `json:"status,required"`
	// The commit status message.
	StatusMessage string `json:"statusMessage,required,nullable"`
	// The total number of tests for the commit.
	TotalGoalCount int64 `json:"totalGoalCount,required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId,required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId,required,nullable" format:"uuid"`
	// Whether the commit is archived.
	Archived bool `json:"archived,nullable"`
	// The deployment status associated with the commit's model.
	DeploymentStatus string                              `json:"deploymentStatus"`
	Links            ProjectCommitListResponseItemsLinks `json:"links"`
	JSON             projectCommitListResponseItemJSON   `json:"-"`
}

func (*ProjectCommitListResponseItem) UnmarshalJSON 

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

type ProjectCommitListResponseItemsCommit 

type ProjectCommitListResponseItemsCommit struct {
	// The commit id.
	ID string `json:"id,required" format:"uuid"`
	// The author id of the commit.
	AuthorID string `json:"authorId,required" format:"uuid"`
	// The size of the commit bundle in bytes.
	FileSize int64 `json:"fileSize,required,nullable"`
	// The commit message.
	Message string `json:"message,required"`
	// The model id.
	MlModelID string `json:"mlModelId,required,nullable" format:"uuid"`
	// The storage URI where the commit bundle is stored.
	StorageUri string `json:"storageUri,required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId,required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId,required,nullable" format:"uuid"`
	// The commit creation date.
	DateCreated time.Time `json:"dateCreated" format:"date-time"`
	// The ref of the corresponding git commit.
	GitCommitRef string `json:"gitCommitRef"`
	// The SHA of the corresponding git commit.
	GitCommitSha int64 `json:"gitCommitSha"`
	// The URL of the corresponding git commit.
	GitCommitURL string                                   `json:"gitCommitUrl"`
	JSON         projectCommitListResponseItemsCommitJSON `json:"-"`
}

The details of a commit (project version).

func (*ProjectCommitListResponseItemsCommit) UnmarshalJSON 

func (r *ProjectCommitListResponseItemsCommit) UnmarshalJSON(data []byte) (err error)
type ProjectCommitListResponseItemsLinks struct {
	App  string                                  `json:"app,required"`
	JSON projectCommitListResponseItemsLinksJSON `json:"-"`
}

func (*ProjectCommitListResponseItemsLinks) UnmarshalJSON 

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

type ProjectCommitListResponseItemsStatus 

type ProjectCommitListResponseItemsStatus string

The commit status. Initially, the commit is `queued`, then, it switches to `running`. Finally, it can be `paused`, `failed`, or `completed`. 

const (
	ProjectCommitListResponseItemsStatusQueued    ProjectCommitListResponseItemsStatus = "queued"
	ProjectCommitListResponseItemsStatusRunning   ProjectCommitListResponseItemsStatus = "running"
	ProjectCommitListResponseItemsStatusPaused    ProjectCommitListResponseItemsStatus = "paused"
	ProjectCommitListResponseItemsStatusFailed    ProjectCommitListResponseItemsStatus = "failed"
	ProjectCommitListResponseItemsStatusCompleted ProjectCommitListResponseItemsStatus = "completed"
	ProjectCommitListResponseItemsStatusUnknown   ProjectCommitListResponseItemsStatus = "unknown"
)

func (ProjectCommitListResponseItemsStatus) IsKnown 

func (r ProjectCommitListResponseItemsStatus) IsKnown() bool

type ProjectCommitNewParams 

type ProjectCommitNewParams struct {
	// The details of a commit (project version).
	Commit param.Field[ProjectCommitNewParamsCommit] `json:"commit,required"`
	// The storage URI where the commit bundle is stored.
	StorageUri param.Field[string] `json:"storageUri,required"`
	// Whether the commit is archived.
	Archived param.Field[bool] `json:"archived"`
	// The deployment status associated with the commit's model.
	DeploymentStatus param.Field[string] `json:"deploymentStatus"`
}

func (ProjectCommitNewParams) MarshalJSON 

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

type ProjectCommitNewParamsCommit 

type ProjectCommitNewParamsCommit struct {
	// The commit message.
	Message param.Field[string] `json:"message,required"`
}

The details of a commit (project version).

func (ProjectCommitNewParamsCommit) MarshalJSON 

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

type ProjectCommitNewResponse 

type ProjectCommitNewResponse struct {
	// The project version (commit) id.
	ID string `json:"id,required" format:"uuid"`
	// The details of a commit (project version).
	Commit ProjectCommitNewResponseCommit `json:"commit,required"`
	// The commit archive date.
	DateArchived time.Time `json:"dateArchived,required,nullable" format:"date-time"`
	// The project version (commit) creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The number of tests that are failing for the commit.
	FailingGoalCount int64 `json:"failingGoalCount,required"`
	// The model id.
	MlModelID string `json:"mlModelId,required,nullable" format:"uuid"`
	// The number of tests that are passing for the commit.
	PassingGoalCount int64 `json:"passingGoalCount,required"`
	// The project id.
	ProjectID string `json:"projectId,required" format:"uuid"`
	// The commit status. Initially, the commit is `queued`, then, it switches to
	// `running`. Finally, it can be `paused`, `failed`, or `completed`.
	Status ProjectCommitNewResponseStatus `json:"status,required"`
	// The commit status message.
	StatusMessage string `json:"statusMessage,required,nullable"`
	// The total number of tests for the commit.
	TotalGoalCount int64 `json:"totalGoalCount,required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId,required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId,required,nullable" format:"uuid"`
	// Whether the commit is archived.
	Archived bool `json:"archived,nullable"`
	// The deployment status associated with the commit's model.
	DeploymentStatus string                        `json:"deploymentStatus"`
	Links            ProjectCommitNewResponseLinks `json:"links"`
	JSON             projectCommitNewResponseJSON  `json:"-"`
}

func (*ProjectCommitNewResponse) UnmarshalJSON 

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

type ProjectCommitNewResponseCommit 

type ProjectCommitNewResponseCommit struct {
	// The commit id.
	ID string `json:"id,required" format:"uuid"`
	// The author id of the commit.
	AuthorID string `json:"authorId,required" format:"uuid"`
	// The size of the commit bundle in bytes.
	FileSize int64 `json:"fileSize,required,nullable"`
	// The commit message.
	Message string `json:"message,required"`
	// The model id.
	MlModelID string `json:"mlModelId,required,nullable" format:"uuid"`
	// The storage URI where the commit bundle is stored.
	StorageUri string `json:"storageUri,required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId,required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId,required,nullable" format:"uuid"`
	// The commit creation date.
	DateCreated time.Time `json:"dateCreated" format:"date-time"`
	// The ref of the corresponding git commit.
	GitCommitRef string `json:"gitCommitRef"`
	// The SHA of the corresponding git commit.
	GitCommitSha int64 `json:"gitCommitSha"`
	// The URL of the corresponding git commit.
	GitCommitURL string                             `json:"gitCommitUrl"`
	JSON         projectCommitNewResponseCommitJSON `json:"-"`
}

The details of a commit (project version).

func (*ProjectCommitNewResponseCommit) UnmarshalJSON 

func (r *ProjectCommitNewResponseCommit) UnmarshalJSON(data []byte) (err error)
type ProjectCommitNewResponseLinks struct {
	App  string                            `json:"app,required"`
	JSON projectCommitNewResponseLinksJSON `json:"-"`
}

func (*ProjectCommitNewResponseLinks) UnmarshalJSON 

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

type ProjectCommitNewResponseStatus 

type ProjectCommitNewResponseStatus string

The commit status. Initially, the commit is `queued`, then, it switches to `running`. Finally, it can be `paused`, `failed`, or `completed`. 

const (
	ProjectCommitNewResponseStatusQueued    ProjectCommitNewResponseStatus = "queued"
	ProjectCommitNewResponseStatusRunning   ProjectCommitNewResponseStatus = "running"
	ProjectCommitNewResponseStatusPaused    ProjectCommitNewResponseStatus = "paused"
	ProjectCommitNewResponseStatusFailed    ProjectCommitNewResponseStatus = "failed"
	ProjectCommitNewResponseStatusCompleted ProjectCommitNewResponseStatus = "completed"
	ProjectCommitNewResponseStatusUnknown   ProjectCommitNewResponseStatus = "unknown"
)

func (ProjectCommitNewResponseStatus) IsKnown 

func (r ProjectCommitNewResponseStatus) IsKnown() bool

type ProjectCommitService 

type ProjectCommitService struct {
	Options []option.RequestOption
}

ProjectCommitService contains methods and other services that help with interacting with the openlayer 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 NewProjectCommitService method instead.

func NewProjectCommitService 

func NewProjectCommitService(opts ...option.RequestOption) (r *ProjectCommitService)

NewProjectCommitService 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 (*ProjectCommitService) List 

func (r *ProjectCommitService) List(ctx context.Context, projectID string, query ProjectCommitListParams, opts ...option.RequestOption) (res *ProjectCommitListResponse, err error)

List the commits (project versions) in a project.

func (*ProjectCommitService) New 

func (r *ProjectCommitService) New(ctx context.Context, projectID string, body ProjectCommitNewParams, opts ...option.RequestOption) (res *ProjectCommitNewResponse, err error)

Create a new commit (project version) in a project.

type ProjectInferencePipelineListParams 

type ProjectInferencePipelineListParams struct {
	// Filter list of items by name.
	Name param.Field[string] `query:"name"`
	// The page to return in a paginated query.
	Page param.Field[int64] `query:"page"`
	// Maximum number of items to return per page.
	PerPage param.Field[int64] `query:"perPage"`
}

func (ProjectInferencePipelineListParams) URLQuery 

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

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

type ProjectInferencePipelineListResponse 

type ProjectInferencePipelineListResponse struct {
	Items []ProjectInferencePipelineListResponseItem `json:"items,required"`
	JSON  projectInferencePipelineListResponseJSON   `json:"-"`
}

func (*ProjectInferencePipelineListResponse) UnmarshalJSON 

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

type ProjectInferencePipelineListResponseItem 

type ProjectInferencePipelineListResponseItem struct {
	// The inference pipeline id.
	ID string `json:"id,required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated,required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived,required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation,required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description,required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                                          `json:"failingGoalCount,required"`
	Links            ProjectInferencePipelineListResponseItemsLinks `json:"links,required"`
	// The inference pipeline name.
	Name string `json:"name,required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount,required"`
	// The project id.
	ProjectID string `json:"projectId,required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status ProjectInferencePipelineListResponseItemsStatus `json:"status,required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage,required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                              `json:"totalGoalCount,required"`
	Project        ProjectInferencePipelineListResponseItemsProject   `json:"project,nullable"`
	Workspace      ProjectInferencePipelineListResponseItemsWorkspace `json:"workspace,nullable"`
	// The workspace id.
	WorkspaceID string                                       `json:"workspaceId" format:"uuid"`
	JSON        projectInferencePipelineListResponseItemJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItem) UnmarshalJSON 

func (r *ProjectInferencePipelineListResponseItem) UnmarshalJSON(data []byte) (err error)
type ProjectInferencePipelineListResponseItemsLinks struct {
	App  string                                             `json:"app,required"`
	JSON projectInferencePipelineListResponseItemsLinksJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsLinks) UnmarshalJSON 

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

type ProjectInferencePipelineListResponseItemsProject 

type ProjectInferencePipelineListResponseItemsProject struct {
	// The project id.
	ID string `json:"id,required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount,required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount,required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount,required"`
	// Links to the project.
	Links ProjectInferencePipelineListResponseItemsProjectLinks `json:"links,required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount,required"`
	// The project name.
	Name string `json:"name,required"`
	// The source of the project.
	Source ProjectInferencePipelineListResponseItemsProjectSource `json:"source,required,nullable"`
	// The task type of the project.
	TaskType ProjectInferencePipelineListResponseItemsProjectTaskType `json:"taskType,required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount,required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId,required,nullable" format:"uuid"`
	// The project description.
	Description string                                                  `json:"description,nullable"`
	GitRepo     ProjectInferencePipelineListResponseItemsProjectGitRepo `json:"gitRepo,nullable"`
	JSON        projectInferencePipelineListResponseItemsProjectJSON    `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsProject) UnmarshalJSON 

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

type ProjectInferencePipelineListResponseItemsProjectGitRepo 

type ProjectInferencePipelineListResponseItemsProjectGitRepo struct {
	ID            string                                                      `json:"id,required" format:"uuid"`
	DateConnected time.Time                                                   `json:"dateConnected,required" format:"date-time"`
	DateUpdated   time.Time                                                   `json:"dateUpdated,required" format:"date-time"`
	GitAccountID  string                                                      `json:"gitAccountId,required" format:"uuid"`
	GitID         int64                                                       `json:"gitId,required"`
	Name          string                                                      `json:"name,required"`
	Private       bool                                                        `json:"private,required"`
	ProjectID     string                                                      `json:"projectId,required" format:"uuid"`
	Slug          string                                                      `json:"slug,required"`
	URL           string                                                      `json:"url,required" format:"url"`
	Branch        string                                                      `json:"branch"`
	RootDir       string                                                      `json:"rootDir"`
	JSON          projectInferencePipelineListResponseItemsProjectGitRepoJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsProjectGitRepo) UnmarshalJSON 

func (r *ProjectInferencePipelineListResponseItemsProjectGitRepo) UnmarshalJSON(data []byte) (err error)
type ProjectInferencePipelineListResponseItemsProjectLinks struct {
	App  string                                                    `json:"app,required"`
	JSON projectInferencePipelineListResponseItemsProjectLinksJSON `json:"-"`
}

Links to the project.

func (*ProjectInferencePipelineListResponseItemsProjectLinks) UnmarshalJSON 

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

type ProjectInferencePipelineListResponseItemsProjectSource 

type ProjectInferencePipelineListResponseItemsProjectSource string

The source of the project. 

const (
	ProjectInferencePipelineListResponseItemsProjectSourceWeb  ProjectInferencePipelineListResponseItemsProjectSource = "web"
	ProjectInferencePipelineListResponseItemsProjectSourceAPI  ProjectInferencePipelineListResponseItemsProjectSource = "api"
	ProjectInferencePipelineListResponseItemsProjectSourceNull ProjectInferencePipelineListResponseItemsProjectSource = "null"
)

func (ProjectInferencePipelineListResponseItemsProjectSource) IsKnown 

func (r ProjectInferencePipelineListResponseItemsProjectSource) IsKnown() bool

type ProjectInferencePipelineListResponseItemsProjectTaskType 

type ProjectInferencePipelineListResponseItemsProjectTaskType string

The task type of the project. 

const (
	ProjectInferencePipelineListResponseItemsProjectTaskTypeLlmBase               ProjectInferencePipelineListResponseItemsProjectTaskType = "llm-base"
	ProjectInferencePipelineListResponseItemsProjectTaskTypeTabularClassification ProjectInferencePipelineListResponseItemsProjectTaskType = "tabular-classification"
	ProjectInferencePipelineListResponseItemsProjectTaskTypeTabularRegression     ProjectInferencePipelineListResponseItemsProjectTaskType = "tabular-regression"
	ProjectInferencePipelineListResponseItemsProjectTaskTypeTextClassification    ProjectInferencePipelineListResponseItemsProjectTaskType = "text-classification"
)

func (ProjectInferencePipelineListResponseItemsProjectTaskType) IsKnown 

func (r ProjectInferencePipelineListResponseItemsProjectTaskType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsStatus 

type ProjectInferencePipelineListResponseItemsStatus string

The status of test evaluation for the inference pipeline. 

const (
	ProjectInferencePipelineListResponseItemsStatusQueued    ProjectInferencePipelineListResponseItemsStatus = "queued"
	ProjectInferencePipelineListResponseItemsStatusRunning   ProjectInferencePipelineListResponseItemsStatus = "running"
	ProjectInferencePipelineListResponseItemsStatusPaused    ProjectInferencePipelineListResponseItemsStatus = "paused"
	ProjectInferencePipelineListResponseItemsStatusFailed    ProjectInferencePipelineListResponseItemsStatus = "failed"
	ProjectInferencePipelineListResponseItemsStatusCompleted ProjectInferencePipelineListResponseItemsStatus = "completed"
	ProjectInferencePipelineListResponseItemsStatusUnknown   ProjectInferencePipelineListResponseItemsStatus = "unknown"
)

func (ProjectInferencePipelineListResponseItemsStatus) IsKnown 

func (r ProjectInferencePipelineListResponseItemsStatus) IsKnown() bool

type ProjectInferencePipelineListResponseItemsWorkspace 

type ProjectInferencePipelineListResponseItemsWorkspace struct {
	ID              string                                                           `json:"id,required" format:"uuid"`
	CreatorID       string                                                           `json:"creatorId,required,nullable" format:"uuid"`
	DateCreated     time.Time                                                        `json:"dateCreated,required" format:"date-time"`
	DateUpdated     time.Time                                                        `json:"dateUpdated,required" format:"date-time"`
	InviteCount     int64                                                            `json:"inviteCount,required"`
	MemberCount     int64                                                            `json:"memberCount,required"`
	Name            string                                                           `json:"name,required"`
	PeriodEndDate   time.Time                                                        `json:"periodEndDate,required,nullable" format:"date-time"`
	PeriodStartDate time.Time                                                        `json:"periodStartDate,required,nullable" format:"date-time"`
	ProjectCount    int64                                                            `json:"projectCount,required"`
	Slug            string                                                           `json:"slug,required"`
	Status          ProjectInferencePipelineListResponseItemsWorkspaceStatus         `json:"status,required"`
	MonthlyUsage    []ProjectInferencePipelineListResponseItemsWorkspaceMonthlyUsage `json:"monthlyUsage"`
	SAMLOnlyAccess  bool                                                             `json:"samlOnlyAccess"`
	WildcardDomains []string                                                         `json:"wildcardDomains"`
	JSON            projectInferencePipelineListResponseItemsWorkspaceJSON           `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsWorkspace) UnmarshalJSON 

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

type ProjectInferencePipelineListResponseItemsWorkspaceMonthlyUsage 

type ProjectInferencePipelineListResponseItemsWorkspaceMonthlyUsage struct {
	ExecutionTimeMs int64                                                              `json:"executionTimeMs,nullable"`
	MonthYear       time.Time                                                          `json:"monthYear" format:"date"`
	PredictionCount int64                                                              `json:"predictionCount"`
	JSON            projectInferencePipelineListResponseItemsWorkspaceMonthlyUsageJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsWorkspaceMonthlyUsage) UnmarshalJSON 

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

type ProjectInferencePipelineListResponseItemsWorkspaceStatus 

type ProjectInferencePipelineListResponseItemsWorkspaceStatus string
const (
	ProjectInferencePipelineListResponseItemsWorkspaceStatusActive            ProjectInferencePipelineListResponseItemsWorkspaceStatus = "active"
	ProjectInferencePipelineListResponseItemsWorkspaceStatusPastDue           ProjectInferencePipelineListResponseItemsWorkspaceStatus = "past_due"
	ProjectInferencePipelineListResponseItemsWorkspaceStatusUnpaid            ProjectInferencePipelineListResponseItemsWorkspaceStatus = "unpaid"
	ProjectInferencePipelineListResponseItemsWorkspaceStatusCanceled          ProjectInferencePipelineListResponseItemsWorkspaceStatus = "canceled"
	ProjectInferencePipelineListResponseItemsWorkspaceStatusIncomplete        ProjectInferencePipelineListResponseItemsWorkspaceStatus = "incomplete"
	ProjectInferencePipelineListResponseItemsWorkspaceStatusIncompleteExpired ProjectInferencePipelineListResponseItemsWorkspaceStatus = "incomplete_expired"
	ProjectInferencePipelineListResponseItemsWorkspaceStatusTrialing          ProjectInferencePipelineListResponseItemsWorkspaceStatus = "trialing"
	ProjectInferencePipelineListResponseItemsWorkspaceStatusPaused            ProjectInferencePipelineListResponseItemsWorkspaceStatus = "paused"
)

func (ProjectInferencePipelineListResponseItemsWorkspaceStatus) IsKnown 

func (r ProjectInferencePipelineListResponseItemsWorkspaceStatus) IsKnown() bool

type ProjectInferencePipelineNewParams 

type ProjectInferencePipelineNewParams struct {
	// The inference pipeline description.
	Description param.Field[string] `json:"description,required"`
	// The inference pipeline name.
	Name      param.Field[string]                                     `json:"name,required"`
	Project   param.Field[ProjectInferencePipelineNewParamsProject]   `json:"project"`
	Workspace param.Field[ProjectInferencePipelineNewParamsWorkspace] `json:"workspace"`
}

func (ProjectInferencePipelineNewParams) MarshalJSON 

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

type ProjectInferencePipelineNewParamsProject 

type ProjectInferencePipelineNewParamsProject struct {
	// The project name.
	Name param.Field[string] `json:"name,required"`
	// The task type of the project.
	TaskType param.Field[ProjectInferencePipelineNewParamsProjectTaskType] `json:"taskType,required"`
	// The project description.
	Description param.Field[string] `json:"description"`
}

func (ProjectInferencePipelineNewParamsProject) MarshalJSON 

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

type ProjectInferencePipelineNewParamsProjectGitRepo 

type ProjectInferencePipelineNewParamsProjectGitRepo struct {
	GitAccountID param.Field[string] `json:"gitAccountId,required" format:"uuid"`
	GitID        param.Field[int64]  `json:"gitId,required"`
	Branch       param.Field[string] `json:"branch"`
	RootDir      param.Field[string] `json:"rootDir"`
}

func (ProjectInferencePipelineNewParamsProjectGitRepo) MarshalJSON 

func (r ProjectInferencePipelineNewParamsProjectGitRepo) MarshalJSON() (data []byte, err error)
type ProjectInferencePipelineNewParamsProjectLinks struct {
	App param.Field[string] `json:"app,required"`
}

Links to the project.

func (ProjectInferencePipelineNewParamsProjectLinks) MarshalJSON 

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

type ProjectInferencePipelineNewParamsProjectSource 

type ProjectInferencePipelineNewParamsProjectSource string

The source of the project. 

const (
	ProjectInferencePipelineNewParamsProjectSourceWeb  ProjectInferencePipelineNewParamsProjectSource = "web"
	ProjectInferencePipelineNewParamsProjectSourceAPI  ProjectInferencePipelineNewParamsProjectSource = "api"
	ProjectInferencePipelineNewParamsProjectSourceNull ProjectInferencePipelineNewParamsProjectSource = "null"
)

func (ProjectInferencePipelineNewParamsProjectSource) IsKnown 

func (r ProjectInferencePipelineNewParamsProjectSource) IsKnown() bool

type ProjectInferencePipelineNewParamsProjectTaskType 

type ProjectInferencePipelineNewParamsProjectTaskType string

The task type of the project. 

const (
	ProjectInferencePipelineNewParamsProjectTaskTypeLlmBase               ProjectInferencePipelineNewParamsProjectTaskType = "llm-base"
	ProjectInferencePipelineNewParamsProjectTaskTypeTabularClassification ProjectInferencePipelineNewParamsProjectTaskType = "tabular-classification"
	ProjectInferencePipelineNewParamsProjectTaskTypeTabularRegression     ProjectInferencePipelineNewParamsProjectTaskType = "tabular-regression"
	ProjectInferencePipelineNewParamsProjectTaskTypeTextClassification    ProjectInferencePipelineNewParamsProjectTaskType = "text-classification"
)

func (ProjectInferencePipelineNewParamsProjectTaskType) IsKnown 

func (r ProjectInferencePipelineNewParamsProjectTaskType) IsKnown() bool

type ProjectInferencePipelineNewParamsWorkspace 

type ProjectInferencePipelineNewParamsWorkspace struct {
	Name            param.Field[string]   `json:"name,required"`
	Slug            param.Field[string]   `json:"slug,required"`
	InviteCode      param.Field[string]   `json:"inviteCode"`
	SAMLOnlyAccess  param.Field[bool]     `json:"samlOnlyAccess"`
	WildcardDomains param.Field[[]string] `json:"wildcardDomains"`
}

func (ProjectInferencePipelineNewParamsWorkspace) MarshalJSON 

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

type ProjectInferencePipelineNewParamsWorkspaceMonthlyUsage 

type ProjectInferencePipelineNewParamsWorkspaceMonthlyUsage struct {
	ExecutionTimeMs param.Field[int64]     `json:"executionTimeMs"`
	MonthYear       param.Field[time.Time] `json:"monthYear" format:"date"`
	PredictionCount param.Field[int64]     `json:"predictionCount"`
}

func (ProjectInferencePipelineNewParamsWorkspaceMonthlyUsage) MarshalJSON 

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

type ProjectInferencePipelineNewParamsWorkspaceStatus 

type ProjectInferencePipelineNewParamsWorkspaceStatus string
const (
	ProjectInferencePipelineNewParamsWorkspaceStatusActive            ProjectInferencePipelineNewParamsWorkspaceStatus = "active"
	ProjectInferencePipelineNewParamsWorkspaceStatusPastDue           ProjectInferencePipelineNewParamsWorkspaceStatus = "past_due"
	ProjectInferencePipelineNewParamsWorkspaceStatusUnpaid            ProjectInferencePipelineNewParamsWorkspaceStatus = "unpaid"
	ProjectInferencePipelineNewParamsWorkspaceStatusCanceled          ProjectInferencePipelineNewParamsWorkspaceStatus = "canceled"
	ProjectInferencePipelineNewParamsWorkspaceStatusIncomplete        ProjectInferencePipelineNewParamsWorkspaceStatus = "incomplete"
	ProjectInferencePipelineNewParamsWorkspaceStatusIncompleteExpired ProjectInferencePipelineNewParamsWorkspaceStatus = "incomplete_expired"
	ProjectInferencePipelineNewParamsWorkspaceStatusTrialing          ProjectInferencePipelineNewParamsWorkspaceStatus = "trialing"
	ProjectInferencePipelineNewParamsWorkspaceStatusPaused            ProjectInferencePipelineNewParamsWorkspaceStatus = "paused"
)

func (ProjectInferencePipelineNewParamsWorkspaceStatus) IsKnown 

func (r ProjectInferencePipelineNewParamsWorkspaceStatus) IsKnown() bool

type ProjectInferencePipelineNewResponse 

type ProjectInferencePipelineNewResponse struct {
	// The inference pipeline id.
	ID string `json:"id,required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated,required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived,required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation,required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description,required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                                    `json:"failingGoalCount,required"`
	Links            ProjectInferencePipelineNewResponseLinks `json:"links,required"`
	// The inference pipeline name.
	Name string `json:"name,required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount,required"`
	// The project id.
	ProjectID string `json:"projectId,required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status ProjectInferencePipelineNewResponseStatus `json:"status,required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage,required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                        `json:"totalGoalCount,required"`
	Project        ProjectInferencePipelineNewResponseProject   `json:"project,nullable"`
	Workspace      ProjectInferencePipelineNewResponseWorkspace `json:"workspace,nullable"`
	// The workspace id.
	WorkspaceID string                                  `json:"workspaceId" format:"uuid"`
	JSON        projectInferencePipelineNewResponseJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponse) UnmarshalJSON 

func (r *ProjectInferencePipelineNewResponse) UnmarshalJSON(data []byte) (err error)
type ProjectInferencePipelineNewResponseLinks struct {
	App  string                                       `json:"app,required"`
	JSON projectInferencePipelineNewResponseLinksJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseLinks) UnmarshalJSON 

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

type ProjectInferencePipelineNewResponseProject 

type ProjectInferencePipelineNewResponseProject struct {
	// The project id.
	ID string `json:"id,required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount,required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount,required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount,required"`
	// Links to the project.
	Links ProjectInferencePipelineNewResponseProjectLinks `json:"links,required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount,required"`
	// The project name.
	Name string `json:"name,required"`
	// The source of the project.
	Source ProjectInferencePipelineNewResponseProjectSource `json:"source,required,nullable"`
	// The task type of the project.
	TaskType ProjectInferencePipelineNewResponseProjectTaskType `json:"taskType,required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount,required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId,required,nullable" format:"uuid"`
	// The project description.
	Description string                                            `json:"description,nullable"`
	GitRepo     ProjectInferencePipelineNewResponseProjectGitRepo `json:"gitRepo,nullable"`
	JSON        projectInferencePipelineNewResponseProjectJSON    `json:"-"`
}

func (*ProjectInferencePipelineNewResponseProject) UnmarshalJSON 

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

type ProjectInferencePipelineNewResponseProjectGitRepo 

type ProjectInferencePipelineNewResponseProjectGitRepo struct {
	ID            string                                                `json:"id,required" format:"uuid"`
	DateConnected time.Time                                             `json:"dateConnected,required" format:"date-time"`
	DateUpdated   time.Time                                             `json:"dateUpdated,required" format:"date-time"`
	GitAccountID  string                                                `json:"gitAccountId,required" format:"uuid"`
	GitID         int64                                                 `json:"gitId,required"`
	Name          string                                                `json:"name,required"`
	Private       bool                                                  `json:"private,required"`
	ProjectID     string                                                `json:"projectId,required" format:"uuid"`
	Slug          string                                                `json:"slug,required"`
	URL           string                                                `json:"url,required" format:"url"`
	Branch        string                                                `json:"branch"`
	RootDir       string                                                `json:"rootDir"`
	JSON          projectInferencePipelineNewResponseProjectGitRepoJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseProjectGitRepo) UnmarshalJSON 

func (r *ProjectInferencePipelineNewResponseProjectGitRepo) UnmarshalJSON(data []byte) (err error)
type ProjectInferencePipelineNewResponseProjectLinks struct {
	App  string                                              `json:"app,required"`
	JSON projectInferencePipelineNewResponseProjectLinksJSON `json:"-"`
}

Links to the project.

func (*ProjectInferencePipelineNewResponseProjectLinks) UnmarshalJSON 

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

type ProjectInferencePipelineNewResponseProjectSource 

type ProjectInferencePipelineNewResponseProjectSource string

The source of the project. 

const (
	ProjectInferencePipelineNewResponseProjectSourceWeb  ProjectInferencePipelineNewResponseProjectSource = "web"
	ProjectInferencePipelineNewResponseProjectSourceAPI  ProjectInferencePipelineNewResponseProjectSource = "api"
	ProjectInferencePipelineNewResponseProjectSourceNull ProjectInferencePipelineNewResponseProjectSource = "null"
)

func (ProjectInferencePipelineNewResponseProjectSource) IsKnown 

func (r ProjectInferencePipelineNewResponseProjectSource) IsKnown() bool

type ProjectInferencePipelineNewResponseProjectTaskType 

type ProjectInferencePipelineNewResponseProjectTaskType string

The task type of the project. 

const (
	ProjectInferencePipelineNewResponseProjectTaskTypeLlmBase               ProjectInferencePipelineNewResponseProjectTaskType = "llm-base"
	ProjectInferencePipelineNewResponseProjectTaskTypeTabularClassification ProjectInferencePipelineNewResponseProjectTaskType = "tabular-classification"
	ProjectInferencePipelineNewResponseProjectTaskTypeTabularRegression     ProjectInferencePipelineNewResponseProjectTaskType = "tabular-regression"
	ProjectInferencePipelineNewResponseProjectTaskTypeTextClassification    ProjectInferencePipelineNewResponseProjectTaskType = "text-classification"
)

func (ProjectInferencePipelineNewResponseProjectTaskType) IsKnown 

func (r ProjectInferencePipelineNewResponseProjectTaskType) IsKnown() bool

type ProjectInferencePipelineNewResponseStatus 

type ProjectInferencePipelineNewResponseStatus string

The status of test evaluation for the inference pipeline. 

const (
	ProjectInferencePipelineNewResponseStatusQueued    ProjectInferencePipelineNewResponseStatus = "queued"
	ProjectInferencePipelineNewResponseStatusRunning   ProjectInferencePipelineNewResponseStatus = "running"
	ProjectInferencePipelineNewResponseStatusPaused    ProjectInferencePipelineNewResponseStatus = "paused"
	ProjectInferencePipelineNewResponseStatusFailed    ProjectInferencePipelineNewResponseStatus = "failed"
	ProjectInferencePipelineNewResponseStatusCompleted ProjectInferencePipelineNewResponseStatus = "completed"
	ProjectInferencePipelineNewResponseStatusUnknown   ProjectInferencePipelineNewResponseStatus = "unknown"
)

func (ProjectInferencePipelineNewResponseStatus) IsKnown 

func (r ProjectInferencePipelineNewResponseStatus) IsKnown() bool

type ProjectInferencePipelineNewResponseWorkspace 

type ProjectInferencePipelineNewResponseWorkspace struct {
	ID              string                                                     `json:"id,required" format:"uuid"`
	CreatorID       string                                                     `json:"creatorId,required,nullable" format:"uuid"`
	DateCreated     time.Time                                                  `json:"dateCreated,required" format:"date-time"`
	DateUpdated     time.Time                                                  `json:"dateUpdated,required" format:"date-time"`
	InviteCount     int64                                                      `json:"inviteCount,required"`
	MemberCount     int64                                                      `json:"memberCount,required"`
	Name            string                                                     `json:"name,required"`
	PeriodEndDate   time.Time                                                  `json:"periodEndDate,required,nullable" format:"date-time"`
	PeriodStartDate time.Time                                                  `json:"periodStartDate,required,nullable" format:"date-time"`
	ProjectCount    int64                                                      `json:"projectCount,required"`
	Slug            string                                                     `json:"slug,required"`
	Status          ProjectInferencePipelineNewResponseWorkspaceStatus         `json:"status,required"`
	MonthlyUsage    []ProjectInferencePipelineNewResponseWorkspaceMonthlyUsage `json:"monthlyUsage"`
	SAMLOnlyAccess  bool                                                       `json:"samlOnlyAccess"`
	WildcardDomains []string                                                   `json:"wildcardDomains"`
	JSON            projectInferencePipelineNewResponseWorkspaceJSON           `json:"-"`
}

func (*ProjectInferencePipelineNewResponseWorkspace) UnmarshalJSON 

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

type ProjectInferencePipelineNewResponseWorkspaceMonthlyUsage 

type ProjectInferencePipelineNewResponseWorkspaceMonthlyUsage struct {
	ExecutionTimeMs int64                                                        `json:"executionTimeMs,nullable"`
	MonthYear       time.Time                                                    `json:"monthYear" format:"date"`
	PredictionCount int64                                                        `json:"predictionCount"`
	JSON            projectInferencePipelineNewResponseWorkspaceMonthlyUsageJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseWorkspaceMonthlyUsage) UnmarshalJSON 

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

type ProjectInferencePipelineNewResponseWorkspaceStatus 

type ProjectInferencePipelineNewResponseWorkspaceStatus string
const (
	ProjectInferencePipelineNewResponseWorkspaceStatusActive            ProjectInferencePipelineNewResponseWorkspaceStatus = "active"
	ProjectInferencePipelineNewResponseWorkspaceStatusPastDue           ProjectInferencePipelineNewResponseWorkspaceStatus = "past_due"
	ProjectInferencePipelineNewResponseWorkspaceStatusUnpaid            ProjectInferencePipelineNewResponseWorkspaceStatus = "unpaid"
	ProjectInferencePipelineNewResponseWorkspaceStatusCanceled          ProjectInferencePipelineNewResponseWorkspaceStatus = "canceled"
	ProjectInferencePipelineNewResponseWorkspaceStatusIncomplete        ProjectInferencePipelineNewResponseWorkspaceStatus = "incomplete"
	ProjectInferencePipelineNewResponseWorkspaceStatusIncompleteExpired ProjectInferencePipelineNewResponseWorkspaceStatus = "incomplete_expired"
	ProjectInferencePipelineNewResponseWorkspaceStatusTrialing          ProjectInferencePipelineNewResponseWorkspaceStatus = "trialing"
	ProjectInferencePipelineNewResponseWorkspaceStatusPaused            ProjectInferencePipelineNewResponseWorkspaceStatus = "paused"
)

func (ProjectInferencePipelineNewResponseWorkspaceStatus) IsKnown 

func (r ProjectInferencePipelineNewResponseWorkspaceStatus) IsKnown() bool

type ProjectInferencePipelineService 

type ProjectInferencePipelineService struct {
	Options []option.RequestOption
}

ProjectInferencePipelineService contains methods and other services that help with interacting with the openlayer 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 NewProjectInferencePipelineService method instead.

func NewProjectInferencePipelineService 

func NewProjectInferencePipelineService(opts ...option.RequestOption) (r *ProjectInferencePipelineService)

NewProjectInferencePipelineService 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 (*ProjectInferencePipelineService) List 

func (r *ProjectInferencePipelineService) List(ctx context.Context, projectID string, query ProjectInferencePipelineListParams, opts ...option.RequestOption) (res *ProjectInferencePipelineListResponse, err error)

List the inference pipelines in a project.

func (*ProjectInferencePipelineService) New 

func (r *ProjectInferencePipelineService) New(ctx context.Context, projectID string, body ProjectInferencePipelineNewParams, opts ...option.RequestOption) (res *ProjectInferencePipelineNewResponse, err error)

Create an inference pipeline in a project.

type ProjectListParams 

type ProjectListParams struct {
	// Filter list of items by project name.
	Name param.Field[string] `query:"name"`
	// The page to return in a paginated query.
	Page param.Field[int64] `query:"page"`
	// Maximum number of items to return per page.
	PerPage param.Field[int64] `query:"perPage"`
	// Filter list of items by task type.
	TaskType param.Field[ProjectListParamsTaskType] `query:"taskType"`
}

func (ProjectListParams) URLQuery 

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

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

type ProjectListParamsTaskType 

type ProjectListParamsTaskType string

Filter list of items by task type. 

const (
	ProjectListParamsTaskTypeLlmBase               ProjectListParamsTaskType = "llm-base"
	ProjectListParamsTaskTypeTabularClassification ProjectListParamsTaskType = "tabular-classification"
	ProjectListParamsTaskTypeTabularRegression     ProjectListParamsTaskType = "tabular-regression"
	ProjectListParamsTaskTypeTextClassification    ProjectListParamsTaskType = "text-classification"
)

func (ProjectListParamsTaskType) IsKnown 

func (r ProjectListParamsTaskType) IsKnown() bool

type ProjectListResponse 

type ProjectListResponse struct {
	Items []ProjectListResponseItem `json:"items,required"`
	JSON  projectListResponseJSON   `json:"-"`
}

func (*ProjectListResponse) UnmarshalJSON 

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

type ProjectListResponseItem 

type ProjectListResponseItem struct {
	// The project id.
	ID string `json:"id,required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount,required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount,required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount,required"`
	// Links to the project.
	Links ProjectListResponseItemsLinks `json:"links,required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount,required"`
	// The project name.
	Name string `json:"name,required"`
	// The source of the project.
	Source ProjectListResponseItemsSource `json:"source,required,nullable"`
	// The task type of the project.
	TaskType ProjectListResponseItemsTaskType `json:"taskType,required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount,required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId,required,nullable" format:"uuid"`
	// The project description.
	Description string                          `json:"description,nullable"`
	GitRepo     ProjectListResponseItemsGitRepo `json:"gitRepo,nullable"`
	JSON        projectListResponseItemJSON     `json:"-"`
}

func (*ProjectListResponseItem) UnmarshalJSON 

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

type ProjectListResponseItemsGitRepo 

type ProjectListResponseItemsGitRepo struct {
	ID            string                              `json:"id,required" format:"uuid"`
	DateConnected time.Time                           `json:"dateConnected,required" format:"date-time"`
	DateUpdated   time.Time                           `json:"dateUpdated,required" format:"date-time"`
	GitAccountID  string                              `json:"gitAccountId,required" format:"uuid"`
	GitID         int64                               `json:"gitId,required"`
	Name          string                              `json:"name,required"`
	Private       bool                                `json:"private,required"`
	ProjectID     string                              `json:"projectId,required" format:"uuid"`
	Slug          string                              `json:"slug,required"`
	URL           string                              `json:"url,required" format:"url"`
	Branch        string                              `json:"branch"`
	RootDir       string                              `json:"rootDir"`
	JSON          projectListResponseItemsGitRepoJSON `json:"-"`
}

func (*ProjectListResponseItemsGitRepo) UnmarshalJSON 

func (r *ProjectListResponseItemsGitRepo) UnmarshalJSON(data []byte) (err error)
type ProjectListResponseItemsLinks struct {
	App  string                            `json:"app,required"`
	JSON projectListResponseItemsLinksJSON `json:"-"`
}

Links to the project.

func (*ProjectListResponseItemsLinks) UnmarshalJSON 

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

type ProjectListResponseItemsSource 

type ProjectListResponseItemsSource string

The source of the project. 

const (
	ProjectListResponseItemsSourceWeb  ProjectListResponseItemsSource = "web"
	ProjectListResponseItemsSourceAPI  ProjectListResponseItemsSource = "api"
	ProjectListResponseItemsSourceNull ProjectListResponseItemsSource = "null"
)

func (ProjectListResponseItemsSource) IsKnown 

func (r ProjectListResponseItemsSource) IsKnown() bool

type ProjectListResponseItemsTaskType 

type ProjectListResponseItemsTaskType string

The task type of the project. 

const (
	ProjectListResponseItemsTaskTypeLlmBase               ProjectListResponseItemsTaskType = "llm-base"
	ProjectListResponseItemsTaskTypeTabularClassification ProjectListResponseItemsTaskType = "tabular-classification"
	ProjectListResponseItemsTaskTypeTabularRegression     ProjectListResponseItemsTaskType = "tabular-regression"
	ProjectListResponseItemsTaskTypeTextClassification    ProjectListResponseItemsTaskType = "text-classification"
)

func (ProjectListResponseItemsTaskType) IsKnown 

func (r ProjectListResponseItemsTaskType) IsKnown() bool

type ProjectNewParams 

type ProjectNewParams struct {
	// The project name.
	Name param.Field[string] `json:"name,required"`
	// The task type of the project.
	TaskType param.Field[ProjectNewParamsTaskType] `json:"taskType,required"`
	// The project description.
	Description param.Field[string] `json:"description"`
}

func (ProjectNewParams) MarshalJSON 

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

type ProjectNewParamsTaskType 

type ProjectNewParamsTaskType string

The task type of the project. 

const (
	ProjectNewParamsTaskTypeLlmBase               ProjectNewParamsTaskType = "llm-base"
	ProjectNewParamsTaskTypeTabularClassification ProjectNewParamsTaskType = "tabular-classification"
	ProjectNewParamsTaskTypeTabularRegression     ProjectNewParamsTaskType = "tabular-regression"
	ProjectNewParamsTaskTypeTextClassification    ProjectNewParamsTaskType = "text-classification"
)

func (ProjectNewParamsTaskType) IsKnown 

func (r ProjectNewParamsTaskType) IsKnown() bool

type ProjectNewResponse 

type ProjectNewResponse struct {
	// The project id.
	ID string `json:"id,required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount,required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount,required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount,required"`
	// Links to the project.
	Links ProjectNewResponseLinks `json:"links,required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount,required"`
	// The project name.
	Name string `json:"name,required"`
	// The source of the project.
	Source ProjectNewResponseSource `json:"source,required,nullable"`
	// The task type of the project.
	TaskType ProjectNewResponseTaskType `json:"taskType,required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount,required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId,required,nullable" format:"uuid"`
	// The project description.
	Description string                    `json:"description,nullable"`
	GitRepo     ProjectNewResponseGitRepo `json:"gitRepo,nullable"`
	JSON        projectNewResponseJSON    `json:"-"`
}

func (*ProjectNewResponse) UnmarshalJSON 

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

type ProjectNewResponseGitRepo 

type ProjectNewResponseGitRepo struct {
	ID            string                        `json:"id,required" format:"uuid"`
	DateConnected time.Time                     `json:"dateConnected,required" format:"date-time"`
	DateUpdated   time.Time                     `json:"dateUpdated,required" format:"date-time"`
	GitAccountID  string                        `json:"gitAccountId,required" format:"uuid"`
	GitID         int64                         `json:"gitId,required"`
	Name          string                        `json:"name,required"`
	Private       bool                          `json:"private,required"`
	ProjectID     string                        `json:"projectId,required" format:"uuid"`
	Slug          string                        `json:"slug,required"`
	URL           string                        `json:"url,required" format:"url"`
	Branch        string                        `json:"branch"`
	RootDir       string                        `json:"rootDir"`
	JSON          projectNewResponseGitRepoJSON `json:"-"`
}

func (*ProjectNewResponseGitRepo) UnmarshalJSON 

func (r *ProjectNewResponseGitRepo) UnmarshalJSON(data []byte) (err error)
type ProjectNewResponseLinks struct {
	App  string                      `json:"app,required"`
	JSON projectNewResponseLinksJSON `json:"-"`
}

Links to the project.

func (*ProjectNewResponseLinks) UnmarshalJSON 

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

type ProjectNewResponseSource 

type ProjectNewResponseSource string

The source of the project. 

const (
	ProjectNewResponseSourceWeb  ProjectNewResponseSource = "web"
	ProjectNewResponseSourceAPI  ProjectNewResponseSource = "api"
	ProjectNewResponseSourceNull ProjectNewResponseSource = "null"
)

func (ProjectNewResponseSource) IsKnown 

func (r ProjectNewResponseSource) IsKnown() bool

type ProjectNewResponseTaskType 

type ProjectNewResponseTaskType string

The task type of the project. 

const (
	ProjectNewResponseTaskTypeLlmBase               ProjectNewResponseTaskType = "llm-base"
	ProjectNewResponseTaskTypeTabularClassification ProjectNewResponseTaskType = "tabular-classification"
	ProjectNewResponseTaskTypeTabularRegression     ProjectNewResponseTaskType = "tabular-regression"
	ProjectNewResponseTaskTypeTextClassification    ProjectNewResponseTaskType = "text-classification"
)

func (ProjectNewResponseTaskType) IsKnown 

func (r ProjectNewResponseTaskType) IsKnown() bool

type ProjectService 

type ProjectService struct {
	Options            []option.RequestOption
	Commits            *ProjectCommitService
	InferencePipelines *ProjectInferencePipelineService
}

ProjectService contains methods and other services that help with interacting with the openlayer 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) List 

func (r *ProjectService) List(ctx context.Context, query ProjectListParams, opts ...option.RequestOption) (res *ProjectListResponse, err error)

List your workspace's projects.

func (*ProjectService) New 

func (r *ProjectService) New(ctx context.Context, body ProjectNewParams, opts ...option.RequestOption) (res *ProjectNewResponse, err error)

Create a project in your workspace.

type StoragePresignedURLNewParams 

type StoragePresignedURLNewParams struct {
	// The name of the object.
	ObjectName param.Field[string] `query:"objectName,required"`
}

func (StoragePresignedURLNewParams) URLQuery 

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

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

type StoragePresignedURLNewResponse 

type StoragePresignedURLNewResponse struct {
	// The storage URI to send back to the backend after the upload was completed.
	StorageUri string `json:"storageUri,required"`
	// The presigned url.
	URL string `json:"url,required" format:"url"`
	// Fields to include in the body of the upload. Only needed by s3
	Fields interface{}                        `json:"fields"`
	JSON   storagePresignedURLNewResponseJSON `json:"-"`
}

func (*StoragePresignedURLNewResponse) UnmarshalJSON 

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

type StoragePresignedURLService 

type StoragePresignedURLService struct {
	Options []option.RequestOption
}

StoragePresignedURLService contains methods and other services that help with interacting with the openlayer 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 NewStoragePresignedURLService method instead.

func NewStoragePresignedURLService 

func NewStoragePresignedURLService(opts ...option.RequestOption) (r *StoragePresignedURLService)

NewStoragePresignedURLService 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 (*StoragePresignedURLService) New 

func (r *StoragePresignedURLService) New(ctx context.Context, body StoragePresignedURLNewParams, opts ...option.RequestOption) (res *StoragePresignedURLNewResponse, err error)

Retrieve a presigned url to post storage artifacts.

type StorageService 

type StorageService struct {
	Options      []option.RequestOption
	PresignedURL *StoragePresignedURLService
}

StorageService contains methods and other services that help with interacting with the openlayer 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 NewStorageService method instead.

func NewStorageService 

func NewStorageService(opts ...option.RequestOption) (r *StorageService)

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

Source Files

View all Source files

Directories

Path Synopsis
apierror
apiform
apijson
apiquery
param
requestconfig
testutil

Jump to

Keyboard shortcuts

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