openlayer

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: Sep 22, 2025 License: Apache-2.0 Imports: 18 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.

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'

Requirements

This library requires Go 1.22+.

Usage

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

package main

import (
	"context"
	"fmt"

	"github.com/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":     7,
				"cost":       0.02,
				"timestamp":  1610000000,
			}}),
		},
	)
	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":     7,
			"cost":       0.02,
			"timestamp":  1610000000,
		}}),
	},
)
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":     7,
			"cost":       0.02,
			"timestamp":  1610000000,
		}}),
	},
	// 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":     7,
			"cost":       0.02,
			"timestamp":  1610000000,
		}}),
	},
	option.WithMaxRetries(5),
)
Accessing raw response data (e.g. response headers)

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

// Create a variable to store the HTTP response
var response *http.Response
response, err := client.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":     7,
			"cost":       0.02,
			"timestamp":  1610000000,
		}}),
	},
	option.WithResponseInto(&response),
)
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", response)

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

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

Undocumented endpoints

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

var (
    // params can be an io.Reader, a []byte, an encoding/json serializable object,
    // or a "…Params" struct defined in this library.
    params map[string]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 DefaultClientOptions 

func DefaultClientOptions() []option.RequestOption

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

func F 

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

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

func FileParam 

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

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

func Float 

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

Float is a param field helper which helps specify floats.

func Int 

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

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

func Null 

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

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

func Raw 

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

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

func String 

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

String is a param field helper which helps specify strings.

Types

type Client 

type Client struct {
	Options            []option.RequestOption
	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, OPENLAYER_BASE_URL). The option passed in as arguments are applied after these default arguments, and all option will be passed down to the services and requests that this client makes.

func (*Client) Delete 

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

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

func (*Client) Execute 

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

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

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

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

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

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

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

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

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

func (*Client) Get 

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

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

func (*Client) Patch 

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

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

func (*Client) Post 

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

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

func (*Client) Put 

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

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

type CommitGetResponse 

type CommitGetResponse struct {
	// The project version (commit) id.
	ID string `json:"id,required" format:"uuid"`
	// The details of a commit (project version).
	Commit CommitGetResponseCommit `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 CommitGetResponseStatus `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            CommitGetResponseLinks `json:"links"`
	JSON             commitGetResponseJSON  `json:"-"`
}

func (*CommitGetResponse) UnmarshalJSON 

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

type CommitGetResponseCommit 

type CommitGetResponseCommit 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         commitGetResponseCommitJSON `json:"-"`
}

The details of a commit (project version).

func (*CommitGetResponseCommit) UnmarshalJSON 

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

func (*CommitGetResponseLinks) UnmarshalJSON 

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

type CommitGetResponseStatus 

type CommitGetResponseStatus string

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

const (
	CommitGetResponseStatusQueued    CommitGetResponseStatus = "queued"
	CommitGetResponseStatusRunning   CommitGetResponseStatus = "running"
	CommitGetResponseStatusPaused    CommitGetResponseStatus = "paused"
	CommitGetResponseStatusFailed    CommitGetResponseStatus = "failed"
	CommitGetResponseStatusCompleted CommitGetResponseStatus = "completed"
	CommitGetResponseStatusUnknown   CommitGetResponseStatus = "unknown"
)

func (CommitGetResponseStatus) IsKnown 

func (r CommitGetResponseStatus) IsKnown() bool

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.

func (*CommitService) Get 

func (r *CommitService) Get(ctx context.Context, projectVersionID string, opts ...option.RequestOption) (res *CommitGetResponse, err error)

Retrieve a project version (commit) by its id.

type CommitTestResultListParams 

type CommitTestResultListParams struct {
	// Filter for archived tests.
	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 CommitTestResultListResponseItemsGoalSubtype `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 CommitTestResultListResponseItemsGoalType `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 CommitTestResultListResponseItemsGoalSubtype 

type CommitTestResultListResponseItemsGoalSubtype string

The test subtype. 

const (
	CommitTestResultListResponseItemsGoalSubtypeAnomalousColumnCount       CommitTestResultListResponseItemsGoalSubtype = "anomalousColumnCount"
	CommitTestResultListResponseItemsGoalSubtypeCharacterLength            CommitTestResultListResponseItemsGoalSubtype = "characterLength"
	CommitTestResultListResponseItemsGoalSubtypeClassImbalanceRatio        CommitTestResultListResponseItemsGoalSubtype = "classImbalanceRatio"
	CommitTestResultListResponseItemsGoalSubtypeExpectColumnAToBeInColumnB CommitTestResultListResponseItemsGoalSubtype = "expectColumnAToBeInColumnB"
	CommitTestResultListResponseItemsGoalSubtypeColumnAverage              CommitTestResultListResponseItemsGoalSubtype = "columnAverage"
	CommitTestResultListResponseItemsGoalSubtypeColumnDrift                CommitTestResultListResponseItemsGoalSubtype = "columnDrift"
	CommitTestResultListResponseItemsGoalSubtypeColumnStatistic            CommitTestResultListResponseItemsGoalSubtype = "columnStatistic"
	CommitTestResultListResponseItemsGoalSubtypeColumnValuesMatch          CommitTestResultListResponseItemsGoalSubtype = "columnValuesMatch"
	CommitTestResultListResponseItemsGoalSubtypeConflictingLabelRowCount   CommitTestResultListResponseItemsGoalSubtype = "conflictingLabelRowCount"
	CommitTestResultListResponseItemsGoalSubtypeContainsPii                CommitTestResultListResponseItemsGoalSubtype = "containsPii"
	CommitTestResultListResponseItemsGoalSubtypeContainsValidURL           CommitTestResultListResponseItemsGoalSubtype = "containsValidUrl"
	CommitTestResultListResponseItemsGoalSubtypeCorrelatedFeatureCount     CommitTestResultListResponseItemsGoalSubtype = "correlatedFeatureCount"
	CommitTestResultListResponseItemsGoalSubtypeCustomMetricThreshold      CommitTestResultListResponseItemsGoalSubtype = "customMetricThreshold"
	CommitTestResultListResponseItemsGoalSubtypeDuplicateRowCount          CommitTestResultListResponseItemsGoalSubtype = "duplicateRowCount"
	CommitTestResultListResponseItemsGoalSubtypeEmptyFeature               CommitTestResultListResponseItemsGoalSubtype = "emptyFeature"
	CommitTestResultListResponseItemsGoalSubtypeEmptyFeatureCount          CommitTestResultListResponseItemsGoalSubtype = "emptyFeatureCount"
	CommitTestResultListResponseItemsGoalSubtypeDriftedFeatureCount        CommitTestResultListResponseItemsGoalSubtype = "driftedFeatureCount"
	CommitTestResultListResponseItemsGoalSubtypeFeatureMissingValues       CommitTestResultListResponseItemsGoalSubtype = "featureMissingValues"
	CommitTestResultListResponseItemsGoalSubtypeFeatureValueValidation     CommitTestResultListResponseItemsGoalSubtype = "featureValueValidation"
	CommitTestResultListResponseItemsGoalSubtypeGreatExpectations          CommitTestResultListResponseItemsGoalSubtype = "greatExpectations"
	CommitTestResultListResponseItemsGoalSubtypeGroupByColumnStatsCheck    CommitTestResultListResponseItemsGoalSubtype = "groupByColumnStatsCheck"
	CommitTestResultListResponseItemsGoalSubtypeIllFormedRowCount          CommitTestResultListResponseItemsGoalSubtype = "illFormedRowCount"
	CommitTestResultListResponseItemsGoalSubtypeIsCode                     CommitTestResultListResponseItemsGoalSubtype = "isCode"
	CommitTestResultListResponseItemsGoalSubtypeIsJson                     CommitTestResultListResponseItemsGoalSubtype = "isJson"
	CommitTestResultListResponseItemsGoalSubtypeLlmRubricThresholdV2       CommitTestResultListResponseItemsGoalSubtype = "llmRubricThresholdV2"
	CommitTestResultListResponseItemsGoalSubtypeLabelDrift                 CommitTestResultListResponseItemsGoalSubtype = "labelDrift"
	CommitTestResultListResponseItemsGoalSubtypeMetricThreshold            CommitTestResultListResponseItemsGoalSubtype = "metricThreshold"
	CommitTestResultListResponseItemsGoalSubtypeNewCategoryCount           CommitTestResultListResponseItemsGoalSubtype = "newCategoryCount"
	CommitTestResultListResponseItemsGoalSubtypeNewLabelCount              CommitTestResultListResponseItemsGoalSubtype = "newLabelCount"
	CommitTestResultListResponseItemsGoalSubtypeNullRowCount               CommitTestResultListResponseItemsGoalSubtype = "nullRowCount"
	CommitTestResultListResponseItemsGoalSubtypeRowCount                   CommitTestResultListResponseItemsGoalSubtype = "rowCount"
	CommitTestResultListResponseItemsGoalSubtypePpScoreValueValidation     CommitTestResultListResponseItemsGoalSubtype = "ppScoreValueValidation"
	CommitTestResultListResponseItemsGoalSubtypeQuasiConstantFeature       CommitTestResultListResponseItemsGoalSubtype = "quasiConstantFeature"
	CommitTestResultListResponseItemsGoalSubtypeQuasiConstantFeatureCount  CommitTestResultListResponseItemsGoalSubtype = "quasiConstantFeatureCount"
	CommitTestResultListResponseItemsGoalSubtypeSqlQuery                   CommitTestResultListResponseItemsGoalSubtype = "sqlQuery"
	CommitTestResultListResponseItemsGoalSubtypeDtypeValidation            CommitTestResultListResponseItemsGoalSubtype = "dtypeValidation"
	CommitTestResultListResponseItemsGoalSubtypeSentenceLength             CommitTestResultListResponseItemsGoalSubtype = "sentenceLength"
	CommitTestResultListResponseItemsGoalSubtypeSizeRatio                  CommitTestResultListResponseItemsGoalSubtype = "sizeRatio"
	CommitTestResultListResponseItemsGoalSubtypeSpecialCharactersRatio     CommitTestResultListResponseItemsGoalSubtype = "specialCharactersRatio"
	CommitTestResultListResponseItemsGoalSubtypeStringValidation           CommitTestResultListResponseItemsGoalSubtype = "stringValidation"
	CommitTestResultListResponseItemsGoalSubtypeTrainValLeakageRowCount    CommitTestResultListResponseItemsGoalSubtype = "trainValLeakageRowCount"
)

func (CommitTestResultListResponseItemsGoalSubtype) IsKnown 

func (r CommitTestResultListResponseItemsGoalSubtype) IsKnown() bool

type CommitTestResultListResponseItemsGoalThreshold 

type CommitTestResultListResponseItemsGoalThreshold struct {
	// The insight name to be evaluated.
	InsightName CommitTestResultListResponseItemsGoalThresholdsInsightName `json:"insightName"`
	// The insight parameters. Required only for some test subtypes. For example, for
	// tests that require a column name, the insight parameters will be [{'name':
	// 'column_name', 'value': 'Age'}]
	InsightParameters []CommitTestResultListResponseItemsGoalThresholdsInsightParameter `json:"insightParameters,nullable"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator CommitTestResultListResponseItemsGoalThresholdsOperator `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode CommitTestResultListResponseItemsGoalThresholdsThresholdMode `json:"thresholdMode"`
	// The value to be compared.
	Value CommitTestResultListResponseItemsGoalThresholdsValueUnion `json:"value"`
	JSON  commitTestResultListResponseItemsGoalThresholdJSON        `json:"-"`
}

func (*CommitTestResultListResponseItemsGoalThreshold) UnmarshalJSON 

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

type CommitTestResultListResponseItemsGoalThresholdsInsightName 

type CommitTestResultListResponseItemsGoalThresholdsInsightName string

The insight name to be evaluated. 

const (
	CommitTestResultListResponseItemsGoalThresholdsInsightNameCharacterLength            CommitTestResultListResponseItemsGoalThresholdsInsightName = "characterLength"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameClassImbalance             CommitTestResultListResponseItemsGoalThresholdsInsightName = "classImbalance"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameExpectColumnAToBeInColumnB CommitTestResultListResponseItemsGoalThresholdsInsightName = "expectColumnAToBeInColumnB"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameColumnAverage              CommitTestResultListResponseItemsGoalThresholdsInsightName = "columnAverage"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameColumnDrift                CommitTestResultListResponseItemsGoalThresholdsInsightName = "columnDrift"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameColumnValuesMatch          CommitTestResultListResponseItemsGoalThresholdsInsightName = "columnValuesMatch"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameConfidenceDistribution     CommitTestResultListResponseItemsGoalThresholdsInsightName = "confidenceDistribution"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameConflictingLabelRowCount   CommitTestResultListResponseItemsGoalThresholdsInsightName = "conflictingLabelRowCount"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameContainsPii                CommitTestResultListResponseItemsGoalThresholdsInsightName = "containsPii"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameContainsValidURL           CommitTestResultListResponseItemsGoalThresholdsInsightName = "containsValidUrl"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameCorrelatedFeatures         CommitTestResultListResponseItemsGoalThresholdsInsightName = "correlatedFeatures"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameCustomMetric               CommitTestResultListResponseItemsGoalThresholdsInsightName = "customMetric"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameDuplicateRowCount          CommitTestResultListResponseItemsGoalThresholdsInsightName = "duplicateRowCount"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameEmptyFeatures              CommitTestResultListResponseItemsGoalThresholdsInsightName = "emptyFeatures"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameFeatureDrift               CommitTestResultListResponseItemsGoalThresholdsInsightName = "featureDrift"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameFeatureProfile             CommitTestResultListResponseItemsGoalThresholdsInsightName = "featureProfile"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameGreatExpectations          CommitTestResultListResponseItemsGoalThresholdsInsightName = "greatExpectations"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameGroupByColumnStatsCheck    CommitTestResultListResponseItemsGoalThresholdsInsightName = "groupByColumnStatsCheck"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameIllFormedRowCount          CommitTestResultListResponseItemsGoalThresholdsInsightName = "illFormedRowCount"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameIsCode                     CommitTestResultListResponseItemsGoalThresholdsInsightName = "isCode"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameIsJson                     CommitTestResultListResponseItemsGoalThresholdsInsightName = "isJson"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameLlmRubricV2                CommitTestResultListResponseItemsGoalThresholdsInsightName = "llmRubricV2"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameLabelDrift                 CommitTestResultListResponseItemsGoalThresholdsInsightName = "labelDrift"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameMetrics                    CommitTestResultListResponseItemsGoalThresholdsInsightName = "metrics"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameNewCategories              CommitTestResultListResponseItemsGoalThresholdsInsightName = "newCategories"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameNewLabels                  CommitTestResultListResponseItemsGoalThresholdsInsightName = "newLabels"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameNullRowCount               CommitTestResultListResponseItemsGoalThresholdsInsightName = "nullRowCount"
	CommitTestResultListResponseItemsGoalThresholdsInsightNamePpScore                    CommitTestResultListResponseItemsGoalThresholdsInsightName = "ppScore"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameQuasiConstantFeatures      CommitTestResultListResponseItemsGoalThresholdsInsightName = "quasiConstantFeatures"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameSentenceLength             CommitTestResultListResponseItemsGoalThresholdsInsightName = "sentenceLength"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameSizeRatio                  CommitTestResultListResponseItemsGoalThresholdsInsightName = "sizeRatio"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameSpecialCharacters          CommitTestResultListResponseItemsGoalThresholdsInsightName = "specialCharacters"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameStringValidation           CommitTestResultListResponseItemsGoalThresholdsInsightName = "stringValidation"
	CommitTestResultListResponseItemsGoalThresholdsInsightNameTrainValLeakageRowCount    CommitTestResultListResponseItemsGoalThresholdsInsightName = "trainValLeakageRowCount"
)

func (CommitTestResultListResponseItemsGoalThresholdsInsightName) IsKnown 

func (r CommitTestResultListResponseItemsGoalThresholdsInsightName) IsKnown() bool

type CommitTestResultListResponseItemsGoalThresholdsInsightParameter 

type CommitTestResultListResponseItemsGoalThresholdsInsightParameter struct {
	// The name of the insight filter.
	Name  string                                                              `json:"name,required"`
	Value interface{}                                                         `json:"value,required"`
	JSON  commitTestResultListResponseItemsGoalThresholdsInsightParameterJSON `json:"-"`
}

func (*CommitTestResultListResponseItemsGoalThresholdsInsightParameter) UnmarshalJSON 

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

type CommitTestResultListResponseItemsGoalThresholdsOperator 

type CommitTestResultListResponseItemsGoalThresholdsOperator string

The operator to be used for the evaluation. 

const (
	CommitTestResultListResponseItemsGoalThresholdsOperatorIs              CommitTestResultListResponseItemsGoalThresholdsOperator = "is"
	CommitTestResultListResponseItemsGoalThresholdsOperatorGreater         CommitTestResultListResponseItemsGoalThresholdsOperator = ">"
	CommitTestResultListResponseItemsGoalThresholdsOperatorGreaterOrEquals CommitTestResultListResponseItemsGoalThresholdsOperator = ">="
	CommitTestResultListResponseItemsGoalThresholdsOperatorLess            CommitTestResultListResponseItemsGoalThresholdsOperator = "<"
	CommitTestResultListResponseItemsGoalThresholdsOperatorLessOrEquals    CommitTestResultListResponseItemsGoalThresholdsOperator = "<="
	CommitTestResultListResponseItemsGoalThresholdsOperatorNotEquals       CommitTestResultListResponseItemsGoalThresholdsOperator = "!="
)

func (CommitTestResultListResponseItemsGoalThresholdsOperator) IsKnown 

func (r CommitTestResultListResponseItemsGoalThresholdsOperator) IsKnown() bool

type CommitTestResultListResponseItemsGoalThresholdsThresholdMode 

type CommitTestResultListResponseItemsGoalThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	CommitTestResultListResponseItemsGoalThresholdsThresholdModeAutomatic CommitTestResultListResponseItemsGoalThresholdsThresholdMode = "automatic"
	CommitTestResultListResponseItemsGoalThresholdsThresholdModeManual    CommitTestResultListResponseItemsGoalThresholdsThresholdMode = "manual"
)

func (CommitTestResultListResponseItemsGoalThresholdsThresholdMode) IsKnown 

func (r CommitTestResultListResponseItemsGoalThresholdsThresholdMode) IsKnown() bool

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 CommitTestResultListResponseItemsGoalType 

type CommitTestResultListResponseItemsGoalType string

The test type. 

const (
	CommitTestResultListResponseItemsGoalTypeIntegrity   CommitTestResultListResponseItemsGoalType = "integrity"
	CommitTestResultListResponseItemsGoalTypeConsistency CommitTestResultListResponseItemsGoalType = "consistency"
	CommitTestResultListResponseItemsGoalTypePerformance CommitTestResultListResponseItemsGoalType = "performance"
)

func (CommitTestResultListResponseItemsGoalType) IsKnown 

func (r CommitTestResultListResponseItemsGoalType) IsKnown() bool

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 session id.
	SessionIDColumnName param.Field[string] `json:"sessionIdColumnName"`
	// 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"`
	// Name of the column with the user id.
	UserIDColumnName param.Field[string] `json:"userIdColumnName"`
}

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 session id.
	SessionIDColumnName param.Field[string] `json:"sessionIdColumnName"`
	// 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"`
	// Name of the column with the user id.
	UserIDColumnName param.Field[string] `json:"userIdColumnName"`
}

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 {
	// The workspace id.
	ID string `json:"id,required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount,required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount,required"`
	// The workspace name.
	Name string `json:"name,required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate,required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate,required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount,required"`
	// The workspace slug.
	Slug         string                                              `json:"slug,required"`
	Status       InferencePipelineGetResponseWorkspaceStatus         `json:"status,required"`
	MonthlyUsage []InferencePipelineGetResponseWorkspaceMonthlyUsage `json:"monthlyUsage"`
	// Whether the workspace only allows SAML authentication.
	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 InferencePipelineTestResultListResponseItemsGoalSubtype `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 InferencePipelineTestResultListResponseItemsGoalType `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 InferencePipelineTestResultListResponseItemsGoalSubtype 

type InferencePipelineTestResultListResponseItemsGoalSubtype string

The test subtype. 

const (
	InferencePipelineTestResultListResponseItemsGoalSubtypeAnomalousColumnCount       InferencePipelineTestResultListResponseItemsGoalSubtype = "anomalousColumnCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeCharacterLength            InferencePipelineTestResultListResponseItemsGoalSubtype = "characterLength"
	InferencePipelineTestResultListResponseItemsGoalSubtypeClassImbalanceRatio        InferencePipelineTestResultListResponseItemsGoalSubtype = "classImbalanceRatio"
	InferencePipelineTestResultListResponseItemsGoalSubtypeExpectColumnAToBeInColumnB InferencePipelineTestResultListResponseItemsGoalSubtype = "expectColumnAToBeInColumnB"
	InferencePipelineTestResultListResponseItemsGoalSubtypeColumnAverage              InferencePipelineTestResultListResponseItemsGoalSubtype = "columnAverage"
	InferencePipelineTestResultListResponseItemsGoalSubtypeColumnDrift                InferencePipelineTestResultListResponseItemsGoalSubtype = "columnDrift"
	InferencePipelineTestResultListResponseItemsGoalSubtypeColumnStatistic            InferencePipelineTestResultListResponseItemsGoalSubtype = "columnStatistic"
	InferencePipelineTestResultListResponseItemsGoalSubtypeColumnValuesMatch          InferencePipelineTestResultListResponseItemsGoalSubtype = "columnValuesMatch"
	InferencePipelineTestResultListResponseItemsGoalSubtypeConflictingLabelRowCount   InferencePipelineTestResultListResponseItemsGoalSubtype = "conflictingLabelRowCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeContainsPii                InferencePipelineTestResultListResponseItemsGoalSubtype = "containsPii"
	InferencePipelineTestResultListResponseItemsGoalSubtypeContainsValidURL           InferencePipelineTestResultListResponseItemsGoalSubtype = "containsValidUrl"
	InferencePipelineTestResultListResponseItemsGoalSubtypeCorrelatedFeatureCount     InferencePipelineTestResultListResponseItemsGoalSubtype = "correlatedFeatureCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeCustomMetricThreshold      InferencePipelineTestResultListResponseItemsGoalSubtype = "customMetricThreshold"
	InferencePipelineTestResultListResponseItemsGoalSubtypeDuplicateRowCount          InferencePipelineTestResultListResponseItemsGoalSubtype = "duplicateRowCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeEmptyFeature               InferencePipelineTestResultListResponseItemsGoalSubtype = "emptyFeature"
	InferencePipelineTestResultListResponseItemsGoalSubtypeEmptyFeatureCount          InferencePipelineTestResultListResponseItemsGoalSubtype = "emptyFeatureCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeDriftedFeatureCount        InferencePipelineTestResultListResponseItemsGoalSubtype = "driftedFeatureCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeFeatureMissingValues       InferencePipelineTestResultListResponseItemsGoalSubtype = "featureMissingValues"
	InferencePipelineTestResultListResponseItemsGoalSubtypeFeatureValueValidation     InferencePipelineTestResultListResponseItemsGoalSubtype = "featureValueValidation"
	InferencePipelineTestResultListResponseItemsGoalSubtypeGreatExpectations          InferencePipelineTestResultListResponseItemsGoalSubtype = "greatExpectations"
	InferencePipelineTestResultListResponseItemsGoalSubtypeGroupByColumnStatsCheck    InferencePipelineTestResultListResponseItemsGoalSubtype = "groupByColumnStatsCheck"
	InferencePipelineTestResultListResponseItemsGoalSubtypeIllFormedRowCount          InferencePipelineTestResultListResponseItemsGoalSubtype = "illFormedRowCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeIsCode                     InferencePipelineTestResultListResponseItemsGoalSubtype = "isCode"
	InferencePipelineTestResultListResponseItemsGoalSubtypeIsJson                     InferencePipelineTestResultListResponseItemsGoalSubtype = "isJson"
	InferencePipelineTestResultListResponseItemsGoalSubtypeLlmRubricThresholdV2       InferencePipelineTestResultListResponseItemsGoalSubtype = "llmRubricThresholdV2"
	InferencePipelineTestResultListResponseItemsGoalSubtypeLabelDrift                 InferencePipelineTestResultListResponseItemsGoalSubtype = "labelDrift"
	InferencePipelineTestResultListResponseItemsGoalSubtypeMetricThreshold            InferencePipelineTestResultListResponseItemsGoalSubtype = "metricThreshold"
	InferencePipelineTestResultListResponseItemsGoalSubtypeNewCategoryCount           InferencePipelineTestResultListResponseItemsGoalSubtype = "newCategoryCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeNewLabelCount              InferencePipelineTestResultListResponseItemsGoalSubtype = "newLabelCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeNullRowCount               InferencePipelineTestResultListResponseItemsGoalSubtype = "nullRowCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeRowCount                   InferencePipelineTestResultListResponseItemsGoalSubtype = "rowCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypePpScoreValueValidation     InferencePipelineTestResultListResponseItemsGoalSubtype = "ppScoreValueValidation"
	InferencePipelineTestResultListResponseItemsGoalSubtypeQuasiConstantFeature       InferencePipelineTestResultListResponseItemsGoalSubtype = "quasiConstantFeature"
	InferencePipelineTestResultListResponseItemsGoalSubtypeQuasiConstantFeatureCount  InferencePipelineTestResultListResponseItemsGoalSubtype = "quasiConstantFeatureCount"
	InferencePipelineTestResultListResponseItemsGoalSubtypeSqlQuery                   InferencePipelineTestResultListResponseItemsGoalSubtype = "sqlQuery"
	InferencePipelineTestResultListResponseItemsGoalSubtypeDtypeValidation            InferencePipelineTestResultListResponseItemsGoalSubtype = "dtypeValidation"
	InferencePipelineTestResultListResponseItemsGoalSubtypeSentenceLength             InferencePipelineTestResultListResponseItemsGoalSubtype = "sentenceLength"
	InferencePipelineTestResultListResponseItemsGoalSubtypeSizeRatio                  InferencePipelineTestResultListResponseItemsGoalSubtype = "sizeRatio"
	InferencePipelineTestResultListResponseItemsGoalSubtypeSpecialCharactersRatio     InferencePipelineTestResultListResponseItemsGoalSubtype = "specialCharactersRatio"
	InferencePipelineTestResultListResponseItemsGoalSubtypeStringValidation           InferencePipelineTestResultListResponseItemsGoalSubtype = "stringValidation"
	InferencePipelineTestResultListResponseItemsGoalSubtypeTrainValLeakageRowCount    InferencePipelineTestResultListResponseItemsGoalSubtype = "trainValLeakageRowCount"
)

func (InferencePipelineTestResultListResponseItemsGoalSubtype) IsKnown 

func (r InferencePipelineTestResultListResponseItemsGoalSubtype) IsKnown() bool

type InferencePipelineTestResultListResponseItemsGoalThreshold 

type InferencePipelineTestResultListResponseItemsGoalThreshold struct {
	// The insight name to be evaluated.
	InsightName InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName `json:"insightName"`
	// The insight parameters. Required only for some test subtypes. For example, for
	// tests that require a column name, the insight parameters will be [{'name':
	// 'column_name', 'value': 'Age'}]
	InsightParameters []InferencePipelineTestResultListResponseItemsGoalThresholdsInsightParameter `json:"insightParameters,nullable"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator InferencePipelineTestResultListResponseItemsGoalThresholdsOperator `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdMode `json:"thresholdMode"`
	// The value to be compared.
	Value InferencePipelineTestResultListResponseItemsGoalThresholdsValueUnion `json:"value"`
	JSON  inferencePipelineTestResultListResponseItemsGoalThresholdJSON        `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsGoalThreshold) UnmarshalJSON 

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

type InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName 

type InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName string

The insight name to be evaluated. 

const (
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameCharacterLength            InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "characterLength"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameClassImbalance             InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "classImbalance"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameExpectColumnAToBeInColumnB InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "expectColumnAToBeInColumnB"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameColumnAverage              InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "columnAverage"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameColumnDrift                InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "columnDrift"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameColumnValuesMatch          InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "columnValuesMatch"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameConfidenceDistribution     InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "confidenceDistribution"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameConflictingLabelRowCount   InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "conflictingLabelRowCount"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameContainsPii                InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "containsPii"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameContainsValidURL           InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "containsValidUrl"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameCorrelatedFeatures         InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "correlatedFeatures"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameCustomMetric               InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "customMetric"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameDuplicateRowCount          InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "duplicateRowCount"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameEmptyFeatures              InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "emptyFeatures"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameFeatureDrift               InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "featureDrift"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameFeatureProfile             InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "featureProfile"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameGreatExpectations          InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "greatExpectations"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameGroupByColumnStatsCheck    InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "groupByColumnStatsCheck"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameIllFormedRowCount          InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "illFormedRowCount"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameIsCode                     InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "isCode"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameIsJson                     InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "isJson"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameLlmRubricV2                InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "llmRubricV2"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameLabelDrift                 InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "labelDrift"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameMetrics                    InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "metrics"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameNewCategories              InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "newCategories"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameNewLabels                  InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "newLabels"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameNullRowCount               InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "nullRowCount"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNamePpScore                    InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "ppScore"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameQuasiConstantFeatures      InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "quasiConstantFeatures"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameSentenceLength             InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "sentenceLength"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameSizeRatio                  InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "sizeRatio"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameSpecialCharacters          InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "specialCharacters"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameStringValidation           InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "stringValidation"
	InferencePipelineTestResultListResponseItemsGoalThresholdsInsightNameTrainValLeakageRowCount    InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName = "trainValLeakageRowCount"
)

func (InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName) IsKnown 

func (r InferencePipelineTestResultListResponseItemsGoalThresholdsInsightName) IsKnown() bool

type InferencePipelineTestResultListResponseItemsGoalThresholdsInsightParameter 

type InferencePipelineTestResultListResponseItemsGoalThresholdsInsightParameter struct {
	// The name of the insight filter.
	Name  string                                                                         `json:"name,required"`
	Value interface{}                                                                    `json:"value,required"`
	JSON  inferencePipelineTestResultListResponseItemsGoalThresholdsInsightParameterJSON `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsGoalThresholdsInsightParameter) UnmarshalJSON 

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

type InferencePipelineTestResultListResponseItemsGoalThresholdsOperator 

type InferencePipelineTestResultListResponseItemsGoalThresholdsOperator string

The operator to be used for the evaluation. 

const (
	InferencePipelineTestResultListResponseItemsGoalThresholdsOperatorIs              InferencePipelineTestResultListResponseItemsGoalThresholdsOperator = "is"
	InferencePipelineTestResultListResponseItemsGoalThresholdsOperatorGreater         InferencePipelineTestResultListResponseItemsGoalThresholdsOperator = ">"
	InferencePipelineTestResultListResponseItemsGoalThresholdsOperatorGreaterOrEquals InferencePipelineTestResultListResponseItemsGoalThresholdsOperator = ">="
	InferencePipelineTestResultListResponseItemsGoalThresholdsOperatorLess            InferencePipelineTestResultListResponseItemsGoalThresholdsOperator = "<"
	InferencePipelineTestResultListResponseItemsGoalThresholdsOperatorLessOrEquals    InferencePipelineTestResultListResponseItemsGoalThresholdsOperator = "<="
	InferencePipelineTestResultListResponseItemsGoalThresholdsOperatorNotEquals       InferencePipelineTestResultListResponseItemsGoalThresholdsOperator = "!="
)

func (InferencePipelineTestResultListResponseItemsGoalThresholdsOperator) IsKnown 

func (r InferencePipelineTestResultListResponseItemsGoalThresholdsOperator) IsKnown() bool

type InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdMode 

type InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdModeAutomatic InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdMode = "automatic"
	InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdModeManual    InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdMode = "manual"
)

func (InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdMode) IsKnown 

func (r InferencePipelineTestResultListResponseItemsGoalThresholdsThresholdMode) IsKnown() bool

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 InferencePipelineTestResultListResponseItemsGoalType 

type InferencePipelineTestResultListResponseItemsGoalType string

The test type. 

const (
	InferencePipelineTestResultListResponseItemsGoalTypeIntegrity   InferencePipelineTestResultListResponseItemsGoalType = "integrity"
	InferencePipelineTestResultListResponseItemsGoalTypeConsistency InferencePipelineTestResultListResponseItemsGoalType = "consistency"
	InferencePipelineTestResultListResponseItemsGoalTypePerformance InferencePipelineTestResultListResponseItemsGoalType = "performance"
)

func (InferencePipelineTestResultListResponseItemsGoalType) IsKnown 

func (r InferencePipelineTestResultListResponseItemsGoalType) IsKnown() bool

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 {
	// The workspace id.
	ID string `json:"id,required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount,required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount,required"`
	// The workspace name.
	Name string `json:"name,required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate,required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate,required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount,required"`
	// The workspace slug.
	Slug         string                                                 `json:"slug,required"`
	Status       InferencePipelineUpdateResponseWorkspaceStatus         `json:"status,required"`
	MonthlyUsage []InferencePipelineUpdateResponseWorkspaceMonthlyUsage `json:"monthlyUsage"`
	// Whether the workspace only allows SAML authentication.
	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 {
	// The workspace id.
	ID string `json:"id,required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount,required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount,required"`
	// The workspace name.
	Name string `json:"name,required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate,required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate,required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount,required"`
	// The workspace slug.
	Slug         string                                                           `json:"slug,required"`
	Status       ProjectInferencePipelineListResponseItemsWorkspaceStatus         `json:"status,required"`
	MonthlyUsage []ProjectInferencePipelineListResponseItemsWorkspaceMonthlyUsage `json:"monthlyUsage"`
	// Whether the workspace only allows SAML authentication.
	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 {
	// The workspace name.
	Name param.Field[string] `json:"name,required"`
	// The workspace slug.
	Slug param.Field[string] `json:"slug,required"`
	// The workspace invite code.
	InviteCode param.Field[string] `json:"inviteCode"`
	// Whether the workspace only allows SAML authentication.
	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 {
	// The workspace id.
	ID string `json:"id,required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId,required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated,required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated,required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount,required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount,required"`
	// The workspace name.
	Name string `json:"name,required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate,required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate,required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount,required"`
	// The workspace slug.
	Slug         string                                                     `json:"slug,required"`
	Status       ProjectInferencePipelineNewResponseWorkspaceStatus         `json:"status,required"`
	MonthlyUsage []ProjectInferencePipelineNewResponseWorkspaceMonthlyUsage `json:"monthlyUsage"`
	// Whether the workspace only allows SAML authentication.
	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
	Tests              *ProjectTestService
}

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 ProjectTestListParams 

type ProjectTestListParams struct {
	// Filter for archived tests.
	IncludeArchived param.Field[bool] `query:"includeArchived"`
	// Retrive tests created by a specific project version.
	OriginVersionID param.Field[string] `query:"originVersionId" format:"uuid"`
	// 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 for suggested tests.
	Suggested param.Field[bool] `query:"suggested"`
	// Filter objects by test type. Available types are `integrity`, `consistency`,
	// `performance`, `fairness`, and `robustness`.
	Type param.Field[ProjectTestListParamsType] `query:"type"`
	// Retrive tests with usesProductionData (monitoring).
	UsesProductionData param.Field[bool] `query:"usesProductionData"`
}

func (ProjectTestListParams) URLQuery 

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

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

type ProjectTestListParamsType 

type ProjectTestListParamsType string

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

const (
	ProjectTestListParamsTypeIntegrity   ProjectTestListParamsType = "integrity"
	ProjectTestListParamsTypeConsistency ProjectTestListParamsType = "consistency"
	ProjectTestListParamsTypePerformance ProjectTestListParamsType = "performance"
	ProjectTestListParamsTypeFairness    ProjectTestListParamsType = "fairness"
	ProjectTestListParamsTypeRobustness  ProjectTestListParamsType = "robustness"
)

func (ProjectTestListParamsType) IsKnown 

func (r ProjectTestListParamsType) IsKnown() bool

type ProjectTestListResponse 

type ProjectTestListResponse struct {
	Items []ProjectTestListResponseItem `json:"items,required"`
	JSON  projectTestListResponseJSON   `json:"-"`
}

func (*ProjectTestListResponse) UnmarshalJSON 

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

type ProjectTestListResponseItem 

type ProjectTestListResponseItem 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 ProjectTestListResponseItemsSubtype `json:"subtype,required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                    `json:"suggested,required"`
	Thresholds []ProjectTestListResponseItemsThreshold `json:"thresholds,required"`
	// The test type.
	Type ProjectTestListResponseItemsType `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                  projectTestListResponseItemJSON `json:"-"`
}

func (*ProjectTestListResponseItem) UnmarshalJSON 

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

type ProjectTestListResponseItemsSubtype 

type ProjectTestListResponseItemsSubtype string

The test subtype. 

const (
	ProjectTestListResponseItemsSubtypeAnomalousColumnCount       ProjectTestListResponseItemsSubtype = "anomalousColumnCount"
	ProjectTestListResponseItemsSubtypeCharacterLength            ProjectTestListResponseItemsSubtype = "characterLength"
	ProjectTestListResponseItemsSubtypeClassImbalanceRatio        ProjectTestListResponseItemsSubtype = "classImbalanceRatio"
	ProjectTestListResponseItemsSubtypeExpectColumnAToBeInColumnB ProjectTestListResponseItemsSubtype = "expectColumnAToBeInColumnB"
	ProjectTestListResponseItemsSubtypeColumnAverage              ProjectTestListResponseItemsSubtype = "columnAverage"
	ProjectTestListResponseItemsSubtypeColumnDrift                ProjectTestListResponseItemsSubtype = "columnDrift"
	ProjectTestListResponseItemsSubtypeColumnStatistic            ProjectTestListResponseItemsSubtype = "columnStatistic"
	ProjectTestListResponseItemsSubtypeColumnValuesMatch          ProjectTestListResponseItemsSubtype = "columnValuesMatch"
	ProjectTestListResponseItemsSubtypeConflictingLabelRowCount   ProjectTestListResponseItemsSubtype = "conflictingLabelRowCount"
	ProjectTestListResponseItemsSubtypeContainsPii                ProjectTestListResponseItemsSubtype = "containsPii"
	ProjectTestListResponseItemsSubtypeContainsValidURL           ProjectTestListResponseItemsSubtype = "containsValidUrl"
	ProjectTestListResponseItemsSubtypeCorrelatedFeatureCount     ProjectTestListResponseItemsSubtype = "correlatedFeatureCount"
	ProjectTestListResponseItemsSubtypeCustomMetricThreshold      ProjectTestListResponseItemsSubtype = "customMetricThreshold"
	ProjectTestListResponseItemsSubtypeDuplicateRowCount          ProjectTestListResponseItemsSubtype = "duplicateRowCount"
	ProjectTestListResponseItemsSubtypeEmptyFeature               ProjectTestListResponseItemsSubtype = "emptyFeature"
	ProjectTestListResponseItemsSubtypeEmptyFeatureCount          ProjectTestListResponseItemsSubtype = "emptyFeatureCount"
	ProjectTestListResponseItemsSubtypeDriftedFeatureCount        ProjectTestListResponseItemsSubtype = "driftedFeatureCount"
	ProjectTestListResponseItemsSubtypeFeatureMissingValues       ProjectTestListResponseItemsSubtype = "featureMissingValues"
	ProjectTestListResponseItemsSubtypeFeatureValueValidation     ProjectTestListResponseItemsSubtype = "featureValueValidation"
	ProjectTestListResponseItemsSubtypeGreatExpectations          ProjectTestListResponseItemsSubtype = "greatExpectations"
	ProjectTestListResponseItemsSubtypeGroupByColumnStatsCheck    ProjectTestListResponseItemsSubtype = "groupByColumnStatsCheck"
	ProjectTestListResponseItemsSubtypeIllFormedRowCount          ProjectTestListResponseItemsSubtype = "illFormedRowCount"
	ProjectTestListResponseItemsSubtypeIsCode                     ProjectTestListResponseItemsSubtype = "isCode"
	ProjectTestListResponseItemsSubtypeIsJson                     ProjectTestListResponseItemsSubtype = "isJson"
	ProjectTestListResponseItemsSubtypeLlmRubricThresholdV2       ProjectTestListResponseItemsSubtype = "llmRubricThresholdV2"
	ProjectTestListResponseItemsSubtypeLabelDrift                 ProjectTestListResponseItemsSubtype = "labelDrift"
	ProjectTestListResponseItemsSubtypeMetricThreshold            ProjectTestListResponseItemsSubtype = "metricThreshold"
	ProjectTestListResponseItemsSubtypeNewCategoryCount           ProjectTestListResponseItemsSubtype = "newCategoryCount"
	ProjectTestListResponseItemsSubtypeNewLabelCount              ProjectTestListResponseItemsSubtype = "newLabelCount"
	ProjectTestListResponseItemsSubtypeNullRowCount               ProjectTestListResponseItemsSubtype = "nullRowCount"
	ProjectTestListResponseItemsSubtypeRowCount                   ProjectTestListResponseItemsSubtype = "rowCount"
	ProjectTestListResponseItemsSubtypePpScoreValueValidation     ProjectTestListResponseItemsSubtype = "ppScoreValueValidation"
	ProjectTestListResponseItemsSubtypeQuasiConstantFeature       ProjectTestListResponseItemsSubtype = "quasiConstantFeature"
	ProjectTestListResponseItemsSubtypeQuasiConstantFeatureCount  ProjectTestListResponseItemsSubtype = "quasiConstantFeatureCount"
	ProjectTestListResponseItemsSubtypeSqlQuery                   ProjectTestListResponseItemsSubtype = "sqlQuery"
	ProjectTestListResponseItemsSubtypeDtypeValidation            ProjectTestListResponseItemsSubtype = "dtypeValidation"
	ProjectTestListResponseItemsSubtypeSentenceLength             ProjectTestListResponseItemsSubtype = "sentenceLength"
	ProjectTestListResponseItemsSubtypeSizeRatio                  ProjectTestListResponseItemsSubtype = "sizeRatio"
	ProjectTestListResponseItemsSubtypeSpecialCharactersRatio     ProjectTestListResponseItemsSubtype = "specialCharactersRatio"
	ProjectTestListResponseItemsSubtypeStringValidation           ProjectTestListResponseItemsSubtype = "stringValidation"
	ProjectTestListResponseItemsSubtypeTrainValLeakageRowCount    ProjectTestListResponseItemsSubtype = "trainValLeakageRowCount"
)

func (ProjectTestListResponseItemsSubtype) IsKnown 

func (r ProjectTestListResponseItemsSubtype) IsKnown() bool

type ProjectTestListResponseItemsThreshold 

type ProjectTestListResponseItemsThreshold struct {
	// The insight name to be evaluated.
	InsightName ProjectTestListResponseItemsThresholdsInsightName `json:"insightName"`
	// The insight parameters. Required only for some test subtypes. For example, for
	// tests that require a column name, the insight parameters will be [{'name':
	// 'column_name', 'value': 'Age'}]
	InsightParameters []ProjectTestListResponseItemsThresholdsInsightParameter `json:"insightParameters,nullable"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator ProjectTestListResponseItemsThresholdsOperator `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode ProjectTestListResponseItemsThresholdsThresholdMode `json:"thresholdMode"`
	// The value to be compared.
	Value ProjectTestListResponseItemsThresholdsValueUnion `json:"value"`
	JSON  projectTestListResponseItemsThresholdJSON        `json:"-"`
}

func (*ProjectTestListResponseItemsThreshold) UnmarshalJSON 

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

type ProjectTestListResponseItemsThresholdsInsightName 

type ProjectTestListResponseItemsThresholdsInsightName string

The insight name to be evaluated. 

const (
	ProjectTestListResponseItemsThresholdsInsightNameCharacterLength            ProjectTestListResponseItemsThresholdsInsightName = "characterLength"
	ProjectTestListResponseItemsThresholdsInsightNameClassImbalance             ProjectTestListResponseItemsThresholdsInsightName = "classImbalance"
	ProjectTestListResponseItemsThresholdsInsightNameExpectColumnAToBeInColumnB ProjectTestListResponseItemsThresholdsInsightName = "expectColumnAToBeInColumnB"
	ProjectTestListResponseItemsThresholdsInsightNameColumnAverage              ProjectTestListResponseItemsThresholdsInsightName = "columnAverage"
	ProjectTestListResponseItemsThresholdsInsightNameColumnDrift                ProjectTestListResponseItemsThresholdsInsightName = "columnDrift"
	ProjectTestListResponseItemsThresholdsInsightNameColumnValuesMatch          ProjectTestListResponseItemsThresholdsInsightName = "columnValuesMatch"
	ProjectTestListResponseItemsThresholdsInsightNameConfidenceDistribution     ProjectTestListResponseItemsThresholdsInsightName = "confidenceDistribution"
	ProjectTestListResponseItemsThresholdsInsightNameConflictingLabelRowCount   ProjectTestListResponseItemsThresholdsInsightName = "conflictingLabelRowCount"
	ProjectTestListResponseItemsThresholdsInsightNameContainsPii                ProjectTestListResponseItemsThresholdsInsightName = "containsPii"
	ProjectTestListResponseItemsThresholdsInsightNameContainsValidURL           ProjectTestListResponseItemsThresholdsInsightName = "containsValidUrl"
	ProjectTestListResponseItemsThresholdsInsightNameCorrelatedFeatures         ProjectTestListResponseItemsThresholdsInsightName = "correlatedFeatures"
	ProjectTestListResponseItemsThresholdsInsightNameCustomMetric               ProjectTestListResponseItemsThresholdsInsightName = "customMetric"
	ProjectTestListResponseItemsThresholdsInsightNameDuplicateRowCount          ProjectTestListResponseItemsThresholdsInsightName = "duplicateRowCount"
	ProjectTestListResponseItemsThresholdsInsightNameEmptyFeatures              ProjectTestListResponseItemsThresholdsInsightName = "emptyFeatures"
	ProjectTestListResponseItemsThresholdsInsightNameFeatureDrift               ProjectTestListResponseItemsThresholdsInsightName = "featureDrift"
	ProjectTestListResponseItemsThresholdsInsightNameFeatureProfile             ProjectTestListResponseItemsThresholdsInsightName = "featureProfile"
	ProjectTestListResponseItemsThresholdsInsightNameGreatExpectations          ProjectTestListResponseItemsThresholdsInsightName = "greatExpectations"
	ProjectTestListResponseItemsThresholdsInsightNameGroupByColumnStatsCheck    ProjectTestListResponseItemsThresholdsInsightName = "groupByColumnStatsCheck"
	ProjectTestListResponseItemsThresholdsInsightNameIllFormedRowCount          ProjectTestListResponseItemsThresholdsInsightName = "illFormedRowCount"
	ProjectTestListResponseItemsThresholdsInsightNameIsCode                     ProjectTestListResponseItemsThresholdsInsightName = "isCode"
	ProjectTestListResponseItemsThresholdsInsightNameIsJson                     ProjectTestListResponseItemsThresholdsInsightName = "isJson"
	ProjectTestListResponseItemsThresholdsInsightNameLlmRubricV2                ProjectTestListResponseItemsThresholdsInsightName = "llmRubricV2"
	ProjectTestListResponseItemsThresholdsInsightNameLabelDrift                 ProjectTestListResponseItemsThresholdsInsightName = "labelDrift"
	ProjectTestListResponseItemsThresholdsInsightNameMetrics                    ProjectTestListResponseItemsThresholdsInsightName = "metrics"
	ProjectTestListResponseItemsThresholdsInsightNameNewCategories              ProjectTestListResponseItemsThresholdsInsightName = "newCategories"
	ProjectTestListResponseItemsThresholdsInsightNameNewLabels                  ProjectTestListResponseItemsThresholdsInsightName = "newLabels"
	ProjectTestListResponseItemsThresholdsInsightNameNullRowCount               ProjectTestListResponseItemsThresholdsInsightName = "nullRowCount"
	ProjectTestListResponseItemsThresholdsInsightNamePpScore                    ProjectTestListResponseItemsThresholdsInsightName = "ppScore"
	ProjectTestListResponseItemsThresholdsInsightNameQuasiConstantFeatures      ProjectTestListResponseItemsThresholdsInsightName = "quasiConstantFeatures"
	ProjectTestListResponseItemsThresholdsInsightNameSentenceLength             ProjectTestListResponseItemsThresholdsInsightName = "sentenceLength"
	ProjectTestListResponseItemsThresholdsInsightNameSizeRatio                  ProjectTestListResponseItemsThresholdsInsightName = "sizeRatio"
	ProjectTestListResponseItemsThresholdsInsightNameSpecialCharacters          ProjectTestListResponseItemsThresholdsInsightName = "specialCharacters"
	ProjectTestListResponseItemsThresholdsInsightNameStringValidation           ProjectTestListResponseItemsThresholdsInsightName = "stringValidation"
	ProjectTestListResponseItemsThresholdsInsightNameTrainValLeakageRowCount    ProjectTestListResponseItemsThresholdsInsightName = "trainValLeakageRowCount"
)

func (ProjectTestListResponseItemsThresholdsInsightName) IsKnown 

func (r ProjectTestListResponseItemsThresholdsInsightName) IsKnown() bool

type ProjectTestListResponseItemsThresholdsInsightParameter 

type ProjectTestListResponseItemsThresholdsInsightParameter struct {
	// The name of the insight filter.
	Name  string                                                     `json:"name,required"`
	Value interface{}                                                `json:"value,required"`
	JSON  projectTestListResponseItemsThresholdsInsightParameterJSON `json:"-"`
}

func (*ProjectTestListResponseItemsThresholdsInsightParameter) UnmarshalJSON 

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

type ProjectTestListResponseItemsThresholdsOperator 

type ProjectTestListResponseItemsThresholdsOperator string

The operator to be used for the evaluation. 

const (
	ProjectTestListResponseItemsThresholdsOperatorIs              ProjectTestListResponseItemsThresholdsOperator = "is"
	ProjectTestListResponseItemsThresholdsOperatorGreater         ProjectTestListResponseItemsThresholdsOperator = ">"
	ProjectTestListResponseItemsThresholdsOperatorGreaterOrEquals ProjectTestListResponseItemsThresholdsOperator = ">="
	ProjectTestListResponseItemsThresholdsOperatorLess            ProjectTestListResponseItemsThresholdsOperator = "<"
	ProjectTestListResponseItemsThresholdsOperatorLessOrEquals    ProjectTestListResponseItemsThresholdsOperator = "<="
	ProjectTestListResponseItemsThresholdsOperatorNotEquals       ProjectTestListResponseItemsThresholdsOperator = "!="
)

func (ProjectTestListResponseItemsThresholdsOperator) IsKnown 

func (r ProjectTestListResponseItemsThresholdsOperator) IsKnown() bool

type ProjectTestListResponseItemsThresholdsThresholdMode 

type ProjectTestListResponseItemsThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	ProjectTestListResponseItemsThresholdsThresholdModeAutomatic ProjectTestListResponseItemsThresholdsThresholdMode = "automatic"
	ProjectTestListResponseItemsThresholdsThresholdModeManual    ProjectTestListResponseItemsThresholdsThresholdMode = "manual"
)

func (ProjectTestListResponseItemsThresholdsThresholdMode) IsKnown 

func (r ProjectTestListResponseItemsThresholdsThresholdMode) IsKnown() bool

type ProjectTestListResponseItemsThresholdsValueArray 

type ProjectTestListResponseItemsThresholdsValueArray []string

func (ProjectTestListResponseItemsThresholdsValueArray) ImplementsProjectTestListResponseItemsThresholdsValueUnion 

func (r ProjectTestListResponseItemsThresholdsValueArray) ImplementsProjectTestListResponseItemsThresholdsValueUnion()

type ProjectTestListResponseItemsThresholdsValueUnion 

type ProjectTestListResponseItemsThresholdsValueUnion interface {
	ImplementsProjectTestListResponseItemsThresholdsValueUnion()
}

The value to be compared.

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

type ProjectTestListResponseItemsType 

type ProjectTestListResponseItemsType string

The test type. 

const (
	ProjectTestListResponseItemsTypeIntegrity   ProjectTestListResponseItemsType = "integrity"
	ProjectTestListResponseItemsTypeConsistency ProjectTestListResponseItemsType = "consistency"
	ProjectTestListResponseItemsTypePerformance ProjectTestListResponseItemsType = "performance"
)

func (ProjectTestListResponseItemsType) IsKnown 

func (r ProjectTestListResponseItemsType) IsKnown() bool

type ProjectTestNewParams 

type ProjectTestNewParams struct {
	// The test description.
	Description param.Field[interface{}] `json:"description,required"`
	// The test name.
	Name param.Field[string] `json:"name,required"`
	// The test subtype.
	Subtype    param.Field[ProjectTestNewParamsSubtype]     `json:"subtype,required"`
	Thresholds param.Field[[]ProjectTestNewParamsThreshold] `json:"thresholds,required"`
	// The test type.
	Type param.Field[ProjectTestNewParamsType] `json:"type,required"`
	// Whether the test is archived.
	Archived param.Field[bool] `json:"archived"`
	// The delay window in seconds. Only applies to tests that use production data.
	DelayWindow param.Field[float64] `json:"delayWindow"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow param.Field[float64] `json:"evaluationWindow"`
	// Whether the test uses an ML model.
	UsesMlModel param.Field[bool] `json:"usesMlModel"`
	// Whether the test uses production data (monitoring mode only).
	UsesProductionData param.Field[bool] `json:"usesProductionData"`
	// Whether the test uses a reference dataset (monitoring mode only).
	UsesReferenceDataset param.Field[bool] `json:"usesReferenceDataset"`
	// Whether the test uses a training dataset.
	UsesTrainingDataset param.Field[bool] `json:"usesTrainingDataset"`
	// Whether the test uses a validation dataset.
	UsesValidationDataset param.Field[bool] `json:"usesValidationDataset"`
}

func (ProjectTestNewParams) MarshalJSON 

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

type ProjectTestNewParamsSubtype 

type ProjectTestNewParamsSubtype string

The test subtype. 

const (
	ProjectTestNewParamsSubtypeAnomalousColumnCount       ProjectTestNewParamsSubtype = "anomalousColumnCount"
	ProjectTestNewParamsSubtypeCharacterLength            ProjectTestNewParamsSubtype = "characterLength"
	ProjectTestNewParamsSubtypeClassImbalanceRatio        ProjectTestNewParamsSubtype = "classImbalanceRatio"
	ProjectTestNewParamsSubtypeExpectColumnAToBeInColumnB ProjectTestNewParamsSubtype = "expectColumnAToBeInColumnB"
	ProjectTestNewParamsSubtypeColumnAverage              ProjectTestNewParamsSubtype = "columnAverage"
	ProjectTestNewParamsSubtypeColumnDrift                ProjectTestNewParamsSubtype = "columnDrift"
	ProjectTestNewParamsSubtypeColumnStatistic            ProjectTestNewParamsSubtype = "columnStatistic"
	ProjectTestNewParamsSubtypeColumnValuesMatch          ProjectTestNewParamsSubtype = "columnValuesMatch"
	ProjectTestNewParamsSubtypeConflictingLabelRowCount   ProjectTestNewParamsSubtype = "conflictingLabelRowCount"
	ProjectTestNewParamsSubtypeContainsPii                ProjectTestNewParamsSubtype = "containsPii"
	ProjectTestNewParamsSubtypeContainsValidURL           ProjectTestNewParamsSubtype = "containsValidUrl"
	ProjectTestNewParamsSubtypeCorrelatedFeatureCount     ProjectTestNewParamsSubtype = "correlatedFeatureCount"
	ProjectTestNewParamsSubtypeCustomMetricThreshold      ProjectTestNewParamsSubtype = "customMetricThreshold"
	ProjectTestNewParamsSubtypeDuplicateRowCount          ProjectTestNewParamsSubtype = "duplicateRowCount"
	ProjectTestNewParamsSubtypeEmptyFeature               ProjectTestNewParamsSubtype = "emptyFeature"
	ProjectTestNewParamsSubtypeEmptyFeatureCount          ProjectTestNewParamsSubtype = "emptyFeatureCount"
	ProjectTestNewParamsSubtypeDriftedFeatureCount        ProjectTestNewParamsSubtype = "driftedFeatureCount"
	ProjectTestNewParamsSubtypeFeatureMissingValues       ProjectTestNewParamsSubtype = "featureMissingValues"
	ProjectTestNewParamsSubtypeFeatureValueValidation     ProjectTestNewParamsSubtype = "featureValueValidation"
	ProjectTestNewParamsSubtypeGreatExpectations          ProjectTestNewParamsSubtype = "greatExpectations"
	ProjectTestNewParamsSubtypeGroupByColumnStatsCheck    ProjectTestNewParamsSubtype = "groupByColumnStatsCheck"
	ProjectTestNewParamsSubtypeIllFormedRowCount          ProjectTestNewParamsSubtype = "illFormedRowCount"
	ProjectTestNewParamsSubtypeIsCode                     ProjectTestNewParamsSubtype = "isCode"
	ProjectTestNewParamsSubtypeIsJson                     ProjectTestNewParamsSubtype = "isJson"
	ProjectTestNewParamsSubtypeLlmRubricThresholdV2       ProjectTestNewParamsSubtype = "llmRubricThresholdV2"
	ProjectTestNewParamsSubtypeLabelDrift                 ProjectTestNewParamsSubtype = "labelDrift"
	ProjectTestNewParamsSubtypeMetricThreshold            ProjectTestNewParamsSubtype = "metricThreshold"
	ProjectTestNewParamsSubtypeNewCategoryCount           ProjectTestNewParamsSubtype = "newCategoryCount"
	ProjectTestNewParamsSubtypeNewLabelCount              ProjectTestNewParamsSubtype = "newLabelCount"
	ProjectTestNewParamsSubtypeNullRowCount               ProjectTestNewParamsSubtype = "nullRowCount"
	ProjectTestNewParamsSubtypeRowCount                   ProjectTestNewParamsSubtype = "rowCount"
	ProjectTestNewParamsSubtypePpScoreValueValidation     ProjectTestNewParamsSubtype = "ppScoreValueValidation"
	ProjectTestNewParamsSubtypeQuasiConstantFeature       ProjectTestNewParamsSubtype = "quasiConstantFeature"
	ProjectTestNewParamsSubtypeQuasiConstantFeatureCount  ProjectTestNewParamsSubtype = "quasiConstantFeatureCount"
	ProjectTestNewParamsSubtypeSqlQuery                   ProjectTestNewParamsSubtype = "sqlQuery"
	ProjectTestNewParamsSubtypeDtypeValidation            ProjectTestNewParamsSubtype = "dtypeValidation"
	ProjectTestNewParamsSubtypeSentenceLength             ProjectTestNewParamsSubtype = "sentenceLength"
	ProjectTestNewParamsSubtypeSizeRatio                  ProjectTestNewParamsSubtype = "sizeRatio"
	ProjectTestNewParamsSubtypeSpecialCharactersRatio     ProjectTestNewParamsSubtype = "specialCharactersRatio"
	ProjectTestNewParamsSubtypeStringValidation           ProjectTestNewParamsSubtype = "stringValidation"
	ProjectTestNewParamsSubtypeTrainValLeakageRowCount    ProjectTestNewParamsSubtype = "trainValLeakageRowCount"
)

func (ProjectTestNewParamsSubtype) IsKnown 

func (r ProjectTestNewParamsSubtype) IsKnown() bool

type ProjectTestNewParamsThreshold 

type ProjectTestNewParamsThreshold struct {
	// The insight name to be evaluated.
	InsightName param.Field[ProjectTestNewParamsThresholdsInsightName] `json:"insightName"`
	// The insight parameters. Required only for some test subtypes. For example, for
	// tests that require a column name, the insight parameters will be [{'name':
	// 'column_name', 'value': 'Age'}]
	InsightParameters param.Field[[]ProjectTestNewParamsThresholdsInsightParameter] `json:"insightParameters"`
	// The measurement to be evaluated.
	Measurement param.Field[string] `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator param.Field[ProjectTestNewParamsThresholdsOperator] `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode param.Field[ProjectTestNewParamsThresholdsThresholdMode] `json:"thresholdMode"`
	// The value to be compared.
	Value param.Field[ProjectTestNewParamsThresholdsValueUnion] `json:"value"`
}

func (ProjectTestNewParamsThreshold) MarshalJSON 

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

type ProjectTestNewParamsThresholdsInsightName 

type ProjectTestNewParamsThresholdsInsightName string

The insight name to be evaluated. 

const (
	ProjectTestNewParamsThresholdsInsightNameCharacterLength            ProjectTestNewParamsThresholdsInsightName = "characterLength"
	ProjectTestNewParamsThresholdsInsightNameClassImbalance             ProjectTestNewParamsThresholdsInsightName = "classImbalance"
	ProjectTestNewParamsThresholdsInsightNameExpectColumnAToBeInColumnB ProjectTestNewParamsThresholdsInsightName = "expectColumnAToBeInColumnB"
	ProjectTestNewParamsThresholdsInsightNameColumnAverage              ProjectTestNewParamsThresholdsInsightName = "columnAverage"
	ProjectTestNewParamsThresholdsInsightNameColumnDrift                ProjectTestNewParamsThresholdsInsightName = "columnDrift"
	ProjectTestNewParamsThresholdsInsightNameColumnValuesMatch          ProjectTestNewParamsThresholdsInsightName = "columnValuesMatch"
	ProjectTestNewParamsThresholdsInsightNameConfidenceDistribution     ProjectTestNewParamsThresholdsInsightName = "confidenceDistribution"
	ProjectTestNewParamsThresholdsInsightNameConflictingLabelRowCount   ProjectTestNewParamsThresholdsInsightName = "conflictingLabelRowCount"
	ProjectTestNewParamsThresholdsInsightNameContainsPii                ProjectTestNewParamsThresholdsInsightName = "containsPii"
	ProjectTestNewParamsThresholdsInsightNameContainsValidURL           ProjectTestNewParamsThresholdsInsightName = "containsValidUrl"
	ProjectTestNewParamsThresholdsInsightNameCorrelatedFeatures         ProjectTestNewParamsThresholdsInsightName = "correlatedFeatures"
	ProjectTestNewParamsThresholdsInsightNameCustomMetric               ProjectTestNewParamsThresholdsInsightName = "customMetric"
	ProjectTestNewParamsThresholdsInsightNameDuplicateRowCount          ProjectTestNewParamsThresholdsInsightName = "duplicateRowCount"
	ProjectTestNewParamsThresholdsInsightNameEmptyFeatures              ProjectTestNewParamsThresholdsInsightName = "emptyFeatures"
	ProjectTestNewParamsThresholdsInsightNameFeatureDrift               ProjectTestNewParamsThresholdsInsightName = "featureDrift"
	ProjectTestNewParamsThresholdsInsightNameFeatureProfile             ProjectTestNewParamsThresholdsInsightName = "featureProfile"
	ProjectTestNewParamsThresholdsInsightNameGreatExpectations          ProjectTestNewParamsThresholdsInsightName = "greatExpectations"
	ProjectTestNewParamsThresholdsInsightNameGroupByColumnStatsCheck    ProjectTestNewParamsThresholdsInsightName = "groupByColumnStatsCheck"
	ProjectTestNewParamsThresholdsInsightNameIllFormedRowCount          ProjectTestNewParamsThresholdsInsightName = "illFormedRowCount"
	ProjectTestNewParamsThresholdsInsightNameIsCode                     ProjectTestNewParamsThresholdsInsightName = "isCode"
	ProjectTestNewParamsThresholdsInsightNameIsJson                     ProjectTestNewParamsThresholdsInsightName = "isJson"
	ProjectTestNewParamsThresholdsInsightNameLlmRubricV2                ProjectTestNewParamsThresholdsInsightName = "llmRubricV2"
	ProjectTestNewParamsThresholdsInsightNameLabelDrift                 ProjectTestNewParamsThresholdsInsightName = "labelDrift"
	ProjectTestNewParamsThresholdsInsightNameMetrics                    ProjectTestNewParamsThresholdsInsightName = "metrics"
	ProjectTestNewParamsThresholdsInsightNameNewCategories              ProjectTestNewParamsThresholdsInsightName = "newCategories"
	ProjectTestNewParamsThresholdsInsightNameNewLabels                  ProjectTestNewParamsThresholdsInsightName = "newLabels"
	ProjectTestNewParamsThresholdsInsightNameNullRowCount               ProjectTestNewParamsThresholdsInsightName = "nullRowCount"
	ProjectTestNewParamsThresholdsInsightNamePpScore                    ProjectTestNewParamsThresholdsInsightName = "ppScore"
	ProjectTestNewParamsThresholdsInsightNameQuasiConstantFeatures      ProjectTestNewParamsThresholdsInsightName = "quasiConstantFeatures"
	ProjectTestNewParamsThresholdsInsightNameSentenceLength             ProjectTestNewParamsThresholdsInsightName = "sentenceLength"
	ProjectTestNewParamsThresholdsInsightNameSizeRatio                  ProjectTestNewParamsThresholdsInsightName = "sizeRatio"
	ProjectTestNewParamsThresholdsInsightNameSpecialCharacters          ProjectTestNewParamsThresholdsInsightName = "specialCharacters"
	ProjectTestNewParamsThresholdsInsightNameStringValidation           ProjectTestNewParamsThresholdsInsightName = "stringValidation"
	ProjectTestNewParamsThresholdsInsightNameTrainValLeakageRowCount    ProjectTestNewParamsThresholdsInsightName = "trainValLeakageRowCount"
)

func (ProjectTestNewParamsThresholdsInsightName) IsKnown 

func (r ProjectTestNewParamsThresholdsInsightName) IsKnown() bool

type ProjectTestNewParamsThresholdsInsightParameter 

type ProjectTestNewParamsThresholdsInsightParameter struct {
	// The name of the insight filter.
	Name  param.Field[string]      `json:"name,required"`
	Value param.Field[interface{}] `json:"value,required"`
}

func (ProjectTestNewParamsThresholdsInsightParameter) MarshalJSON 

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

type ProjectTestNewParamsThresholdsOperator 

type ProjectTestNewParamsThresholdsOperator string

The operator to be used for the evaluation. 

const (
	ProjectTestNewParamsThresholdsOperatorIs              ProjectTestNewParamsThresholdsOperator = "is"
	ProjectTestNewParamsThresholdsOperatorGreater         ProjectTestNewParamsThresholdsOperator = ">"
	ProjectTestNewParamsThresholdsOperatorGreaterOrEquals ProjectTestNewParamsThresholdsOperator = ">="
	ProjectTestNewParamsThresholdsOperatorLess            ProjectTestNewParamsThresholdsOperator = "<"
	ProjectTestNewParamsThresholdsOperatorLessOrEquals    ProjectTestNewParamsThresholdsOperator = "<="
	ProjectTestNewParamsThresholdsOperatorNotEquals       ProjectTestNewParamsThresholdsOperator = "!="
)

func (ProjectTestNewParamsThresholdsOperator) IsKnown 

func (r ProjectTestNewParamsThresholdsOperator) IsKnown() bool

type ProjectTestNewParamsThresholdsThresholdMode 

type ProjectTestNewParamsThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	ProjectTestNewParamsThresholdsThresholdModeAutomatic ProjectTestNewParamsThresholdsThresholdMode = "automatic"
	ProjectTestNewParamsThresholdsThresholdModeManual    ProjectTestNewParamsThresholdsThresholdMode = "manual"
)

func (ProjectTestNewParamsThresholdsThresholdMode) IsKnown 

func (r ProjectTestNewParamsThresholdsThresholdMode) IsKnown() bool

type ProjectTestNewParamsThresholdsValueArray 

type ProjectTestNewParamsThresholdsValueArray []string

func (ProjectTestNewParamsThresholdsValueArray) ImplementsProjectTestNewParamsThresholdsValueUnion 

func (r ProjectTestNewParamsThresholdsValueArray) ImplementsProjectTestNewParamsThresholdsValueUnion()

type ProjectTestNewParamsThresholdsValueUnion 

type ProjectTestNewParamsThresholdsValueUnion interface {
	ImplementsProjectTestNewParamsThresholdsValueUnion()
}

The value to be compared.

Satisfied by shared.UnionFloat, shared.UnionBool, shared.UnionString, ProjectTestNewParamsThresholdsValueArray.

type ProjectTestNewParamsType 

type ProjectTestNewParamsType string

The test type. 

const (
	ProjectTestNewParamsTypeIntegrity   ProjectTestNewParamsType = "integrity"
	ProjectTestNewParamsTypeConsistency ProjectTestNewParamsType = "consistency"
	ProjectTestNewParamsTypePerformance ProjectTestNewParamsType = "performance"
)

func (ProjectTestNewParamsType) IsKnown 

func (r ProjectTestNewParamsType) IsKnown() bool

type ProjectTestNewResponse 

type ProjectTestNewResponse 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 ProjectTestNewResponseSubtype `json:"subtype,required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                              `json:"suggested,required"`
	Thresholds []ProjectTestNewResponseThreshold `json:"thresholds,required"`
	// The test type.
	Type ProjectTestNewResponseType `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                  projectTestNewResponseJSON `json:"-"`
}

func (*ProjectTestNewResponse) UnmarshalJSON 

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

type ProjectTestNewResponseSubtype 

type ProjectTestNewResponseSubtype string

The test subtype. 

const (
	ProjectTestNewResponseSubtypeAnomalousColumnCount       ProjectTestNewResponseSubtype = "anomalousColumnCount"
	ProjectTestNewResponseSubtypeCharacterLength            ProjectTestNewResponseSubtype = "characterLength"
	ProjectTestNewResponseSubtypeClassImbalanceRatio        ProjectTestNewResponseSubtype = "classImbalanceRatio"
	ProjectTestNewResponseSubtypeExpectColumnAToBeInColumnB ProjectTestNewResponseSubtype = "expectColumnAToBeInColumnB"
	ProjectTestNewResponseSubtypeColumnAverage              ProjectTestNewResponseSubtype = "columnAverage"
	ProjectTestNewResponseSubtypeColumnDrift                ProjectTestNewResponseSubtype = "columnDrift"
	ProjectTestNewResponseSubtypeColumnStatistic            ProjectTestNewResponseSubtype = "columnStatistic"
	ProjectTestNewResponseSubtypeColumnValuesMatch          ProjectTestNewResponseSubtype = "columnValuesMatch"
	ProjectTestNewResponseSubtypeConflictingLabelRowCount   ProjectTestNewResponseSubtype = "conflictingLabelRowCount"
	ProjectTestNewResponseSubtypeContainsPii                ProjectTestNewResponseSubtype = "containsPii"
	ProjectTestNewResponseSubtypeContainsValidURL           ProjectTestNewResponseSubtype = "containsValidUrl"
	ProjectTestNewResponseSubtypeCorrelatedFeatureCount     ProjectTestNewResponseSubtype = "correlatedFeatureCount"
	ProjectTestNewResponseSubtypeCustomMetricThreshold      ProjectTestNewResponseSubtype = "customMetricThreshold"
	ProjectTestNewResponseSubtypeDuplicateRowCount          ProjectTestNewResponseSubtype = "duplicateRowCount"
	ProjectTestNewResponseSubtypeEmptyFeature               ProjectTestNewResponseSubtype = "emptyFeature"
	ProjectTestNewResponseSubtypeEmptyFeatureCount          ProjectTestNewResponseSubtype = "emptyFeatureCount"
	ProjectTestNewResponseSubtypeDriftedFeatureCount        ProjectTestNewResponseSubtype = "driftedFeatureCount"
	ProjectTestNewResponseSubtypeFeatureMissingValues       ProjectTestNewResponseSubtype = "featureMissingValues"
	ProjectTestNewResponseSubtypeFeatureValueValidation     ProjectTestNewResponseSubtype = "featureValueValidation"
	ProjectTestNewResponseSubtypeGreatExpectations          ProjectTestNewResponseSubtype = "greatExpectations"
	ProjectTestNewResponseSubtypeGroupByColumnStatsCheck    ProjectTestNewResponseSubtype = "groupByColumnStatsCheck"
	ProjectTestNewResponseSubtypeIllFormedRowCount          ProjectTestNewResponseSubtype = "illFormedRowCount"
	ProjectTestNewResponseSubtypeIsCode                     ProjectTestNewResponseSubtype = "isCode"
	ProjectTestNewResponseSubtypeIsJson                     ProjectTestNewResponseSubtype = "isJson"
	ProjectTestNewResponseSubtypeLlmRubricThresholdV2       ProjectTestNewResponseSubtype = "llmRubricThresholdV2"
	ProjectTestNewResponseSubtypeLabelDrift                 ProjectTestNewResponseSubtype = "labelDrift"
	ProjectTestNewResponseSubtypeMetricThreshold            ProjectTestNewResponseSubtype = "metricThreshold"
	ProjectTestNewResponseSubtypeNewCategoryCount           ProjectTestNewResponseSubtype = "newCategoryCount"
	ProjectTestNewResponseSubtypeNewLabelCount              ProjectTestNewResponseSubtype = "newLabelCount"
	ProjectTestNewResponseSubtypeNullRowCount               ProjectTestNewResponseSubtype = "nullRowCount"
	ProjectTestNewResponseSubtypeRowCount                   ProjectTestNewResponseSubtype = "rowCount"
	ProjectTestNewResponseSubtypePpScoreValueValidation     ProjectTestNewResponseSubtype = "ppScoreValueValidation"
	ProjectTestNewResponseSubtypeQuasiConstantFeature       ProjectTestNewResponseSubtype = "quasiConstantFeature"
	ProjectTestNewResponseSubtypeQuasiConstantFeatureCount  ProjectTestNewResponseSubtype = "quasiConstantFeatureCount"
	ProjectTestNewResponseSubtypeSqlQuery                   ProjectTestNewResponseSubtype = "sqlQuery"
	ProjectTestNewResponseSubtypeDtypeValidation            ProjectTestNewResponseSubtype = "dtypeValidation"
	ProjectTestNewResponseSubtypeSentenceLength             ProjectTestNewResponseSubtype = "sentenceLength"
	ProjectTestNewResponseSubtypeSizeRatio                  ProjectTestNewResponseSubtype = "sizeRatio"
	ProjectTestNewResponseSubtypeSpecialCharactersRatio     ProjectTestNewResponseSubtype = "specialCharactersRatio"
	ProjectTestNewResponseSubtypeStringValidation           ProjectTestNewResponseSubtype = "stringValidation"
	ProjectTestNewResponseSubtypeTrainValLeakageRowCount    ProjectTestNewResponseSubtype = "trainValLeakageRowCount"
)

func (ProjectTestNewResponseSubtype) IsKnown 

func (r ProjectTestNewResponseSubtype) IsKnown() bool

type ProjectTestNewResponseThreshold 

type ProjectTestNewResponseThreshold struct {
	// The insight name to be evaluated.
	InsightName ProjectTestNewResponseThresholdsInsightName `json:"insightName"`
	// The insight parameters. Required only for some test subtypes. For example, for
	// tests that require a column name, the insight parameters will be [{'name':
	// 'column_name', 'value': 'Age'}]
	InsightParameters []ProjectTestNewResponseThresholdsInsightParameter `json:"insightParameters,nullable"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator ProjectTestNewResponseThresholdsOperator `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode ProjectTestNewResponseThresholdsThresholdMode `json:"thresholdMode"`
	// The value to be compared.
	Value ProjectTestNewResponseThresholdsValueUnion `json:"value"`
	JSON  projectTestNewResponseThresholdJSON        `json:"-"`
}

func (*ProjectTestNewResponseThreshold) UnmarshalJSON 

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

type ProjectTestNewResponseThresholdsInsightName 

type ProjectTestNewResponseThresholdsInsightName string

The insight name to be evaluated. 

const (
	ProjectTestNewResponseThresholdsInsightNameCharacterLength            ProjectTestNewResponseThresholdsInsightName = "characterLength"
	ProjectTestNewResponseThresholdsInsightNameClassImbalance             ProjectTestNewResponseThresholdsInsightName = "classImbalance"
	ProjectTestNewResponseThresholdsInsightNameExpectColumnAToBeInColumnB ProjectTestNewResponseThresholdsInsightName = "expectColumnAToBeInColumnB"
	ProjectTestNewResponseThresholdsInsightNameColumnAverage              ProjectTestNewResponseThresholdsInsightName = "columnAverage"
	ProjectTestNewResponseThresholdsInsightNameColumnDrift                ProjectTestNewResponseThresholdsInsightName = "columnDrift"
	ProjectTestNewResponseThresholdsInsightNameColumnValuesMatch          ProjectTestNewResponseThresholdsInsightName = "columnValuesMatch"
	ProjectTestNewResponseThresholdsInsightNameConfidenceDistribution     ProjectTestNewResponseThresholdsInsightName = "confidenceDistribution"
	ProjectTestNewResponseThresholdsInsightNameConflictingLabelRowCount   ProjectTestNewResponseThresholdsInsightName = "conflictingLabelRowCount"
	ProjectTestNewResponseThresholdsInsightNameContainsPii                ProjectTestNewResponseThresholdsInsightName = "containsPii"
	ProjectTestNewResponseThresholdsInsightNameContainsValidURL           ProjectTestNewResponseThresholdsInsightName = "containsValidUrl"
	ProjectTestNewResponseThresholdsInsightNameCorrelatedFeatures         ProjectTestNewResponseThresholdsInsightName = "correlatedFeatures"
	ProjectTestNewResponseThresholdsInsightNameCustomMetric               ProjectTestNewResponseThresholdsInsightName = "customMetric"
	ProjectTestNewResponseThresholdsInsightNameDuplicateRowCount          ProjectTestNewResponseThresholdsInsightName = "duplicateRowCount"
	ProjectTestNewResponseThresholdsInsightNameEmptyFeatures              ProjectTestNewResponseThresholdsInsightName = "emptyFeatures"
	ProjectTestNewResponseThresholdsInsightNameFeatureDrift               ProjectTestNewResponseThresholdsInsightName = "featureDrift"
	ProjectTestNewResponseThresholdsInsightNameFeatureProfile             ProjectTestNewResponseThresholdsInsightName = "featureProfile"
	ProjectTestNewResponseThresholdsInsightNameGreatExpectations          ProjectTestNewResponseThresholdsInsightName = "greatExpectations"
	ProjectTestNewResponseThresholdsInsightNameGroupByColumnStatsCheck    ProjectTestNewResponseThresholdsInsightName = "groupByColumnStatsCheck"
	ProjectTestNewResponseThresholdsInsightNameIllFormedRowCount          ProjectTestNewResponseThresholdsInsightName = "illFormedRowCount"
	ProjectTestNewResponseThresholdsInsightNameIsCode                     ProjectTestNewResponseThresholdsInsightName = "isCode"
	ProjectTestNewResponseThresholdsInsightNameIsJson                     ProjectTestNewResponseThresholdsInsightName = "isJson"
	ProjectTestNewResponseThresholdsInsightNameLlmRubricV2                ProjectTestNewResponseThresholdsInsightName = "llmRubricV2"
	ProjectTestNewResponseThresholdsInsightNameLabelDrift                 ProjectTestNewResponseThresholdsInsightName = "labelDrift"
	ProjectTestNewResponseThresholdsInsightNameMetrics                    ProjectTestNewResponseThresholdsInsightName = "metrics"
	ProjectTestNewResponseThresholdsInsightNameNewCategories              ProjectTestNewResponseThresholdsInsightName = "newCategories"
	ProjectTestNewResponseThresholdsInsightNameNewLabels                  ProjectTestNewResponseThresholdsInsightName = "newLabels"
	ProjectTestNewResponseThresholdsInsightNameNullRowCount               ProjectTestNewResponseThresholdsInsightName = "nullRowCount"
	ProjectTestNewResponseThresholdsInsightNamePpScore                    ProjectTestNewResponseThresholdsInsightName = "ppScore"
	ProjectTestNewResponseThresholdsInsightNameQuasiConstantFeatures      ProjectTestNewResponseThresholdsInsightName = "quasiConstantFeatures"
	ProjectTestNewResponseThresholdsInsightNameSentenceLength             ProjectTestNewResponseThresholdsInsightName = "sentenceLength"
	ProjectTestNewResponseThresholdsInsightNameSizeRatio                  ProjectTestNewResponseThresholdsInsightName = "sizeRatio"
	ProjectTestNewResponseThresholdsInsightNameSpecialCharacters          ProjectTestNewResponseThresholdsInsightName = "specialCharacters"
	ProjectTestNewResponseThresholdsInsightNameStringValidation           ProjectTestNewResponseThresholdsInsightName = "stringValidation"
	ProjectTestNewResponseThresholdsInsightNameTrainValLeakageRowCount    ProjectTestNewResponseThresholdsInsightName = "trainValLeakageRowCount"
)

func (ProjectTestNewResponseThresholdsInsightName) IsKnown 

func (r ProjectTestNewResponseThresholdsInsightName) IsKnown() bool

type ProjectTestNewResponseThresholdsInsightParameter 

type ProjectTestNewResponseThresholdsInsightParameter struct {
	// The name of the insight filter.
	Name  string                                               `json:"name,required"`
	Value interface{}                                          `json:"value,required"`
	JSON  projectTestNewResponseThresholdsInsightParameterJSON `json:"-"`
}

func (*ProjectTestNewResponseThresholdsInsightParameter) UnmarshalJSON 

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

type ProjectTestNewResponseThresholdsOperator 

type ProjectTestNewResponseThresholdsOperator string

The operator to be used for the evaluation. 

const (
	ProjectTestNewResponseThresholdsOperatorIs              ProjectTestNewResponseThresholdsOperator = "is"
	ProjectTestNewResponseThresholdsOperatorGreater         ProjectTestNewResponseThresholdsOperator = ">"
	ProjectTestNewResponseThresholdsOperatorGreaterOrEquals ProjectTestNewResponseThresholdsOperator = ">="
	ProjectTestNewResponseThresholdsOperatorLess            ProjectTestNewResponseThresholdsOperator = "<"
	ProjectTestNewResponseThresholdsOperatorLessOrEquals    ProjectTestNewResponseThresholdsOperator = "<="
	ProjectTestNewResponseThresholdsOperatorNotEquals       ProjectTestNewResponseThresholdsOperator = "!="
)

func (ProjectTestNewResponseThresholdsOperator) IsKnown 

func (r ProjectTestNewResponseThresholdsOperator) IsKnown() bool

type ProjectTestNewResponseThresholdsThresholdMode 

type ProjectTestNewResponseThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	ProjectTestNewResponseThresholdsThresholdModeAutomatic ProjectTestNewResponseThresholdsThresholdMode = "automatic"
	ProjectTestNewResponseThresholdsThresholdModeManual    ProjectTestNewResponseThresholdsThresholdMode = "manual"
)

func (ProjectTestNewResponseThresholdsThresholdMode) IsKnown 

func (r ProjectTestNewResponseThresholdsThresholdMode) IsKnown() bool

type ProjectTestNewResponseThresholdsValueArray 

type ProjectTestNewResponseThresholdsValueArray []string

func (ProjectTestNewResponseThresholdsValueArray) ImplementsProjectTestNewResponseThresholdsValueUnion 

func (r ProjectTestNewResponseThresholdsValueArray) ImplementsProjectTestNewResponseThresholdsValueUnion()

type ProjectTestNewResponseThresholdsValueUnion 

type ProjectTestNewResponseThresholdsValueUnion interface {
	ImplementsProjectTestNewResponseThresholdsValueUnion()
}

The value to be compared.

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

type ProjectTestNewResponseType 

type ProjectTestNewResponseType string

The test type. 

const (
	ProjectTestNewResponseTypeIntegrity   ProjectTestNewResponseType = "integrity"
	ProjectTestNewResponseTypeConsistency ProjectTestNewResponseType = "consistency"
	ProjectTestNewResponseTypePerformance ProjectTestNewResponseType = "performance"
)

func (ProjectTestNewResponseType) IsKnown 

func (r ProjectTestNewResponseType) IsKnown() bool

type ProjectTestService 

type ProjectTestService struct {
	Options []option.RequestOption
}

ProjectTestService 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 NewProjectTestService method instead.

func NewProjectTestService 

func NewProjectTestService(opts ...option.RequestOption) (r *ProjectTestService)

NewProjectTestService 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 (*ProjectTestService) List 

func (r *ProjectTestService) List(ctx context.Context, projectID string, query ProjectTestListParams, opts ...option.RequestOption) (res *ProjectTestListResponse, err error)

List tests under a project.

func (*ProjectTestService) New 

func (r *ProjectTestService) New(ctx context.Context, projectID string, body ProjectTestNewParams, opts ...option.RequestOption) (res *ProjectTestNewResponse, err error)

Create a test.

func (*ProjectTestService) Update 

func (r *ProjectTestService) Update(ctx context.Context, projectID string, body ProjectTestUpdateParams, opts ...option.RequestOption) (res *ProjectTestUpdateResponse, err error)

Update tests.

type ProjectTestUpdateParams 

type ProjectTestUpdateParams struct {
	Payloads param.Field[[]ProjectTestUpdateParamsPayload] `json:"payloads,required"`
}

func (ProjectTestUpdateParams) MarshalJSON 

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

type ProjectTestUpdateParamsPayload 

type ProjectTestUpdateParamsPayload struct {
	ID param.Field[string] `json:"id,required" format:"uuid"`
	// Whether the test is archived.
	Archived param.Field[bool] `json:"archived"`
	// The test description.
	Description param.Field[interface{}] `json:"description"`
	// The test name.
	Name       param.Field[string]                                     `json:"name"`
	Suggested  param.Field[ProjectTestUpdateParamsPayloadsSuggested]   `json:"suggested"`
	Thresholds param.Field[[]ProjectTestUpdateParamsPayloadsThreshold] `json:"thresholds"`
}

func (ProjectTestUpdateParamsPayload) MarshalJSON 

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

type ProjectTestUpdateParamsPayloadsSuggested 

type ProjectTestUpdateParamsPayloadsSuggested bool
const (
	ProjectTestUpdateParamsPayloadsSuggestedFalse ProjectTestUpdateParamsPayloadsSuggested = false
)

func (ProjectTestUpdateParamsPayloadsSuggested) IsKnown 

func (r ProjectTestUpdateParamsPayloadsSuggested) IsKnown() bool

type ProjectTestUpdateParamsPayloadsThreshold 

type ProjectTestUpdateParamsPayloadsThreshold struct {
	// The insight name to be evaluated.
	InsightName param.Field[ProjectTestUpdateParamsPayloadsThresholdsInsightName] `json:"insightName"`
	// The insight parameters. Required only for some test subtypes. For example, for
	// tests that require a column name, the insight parameters will be [{'name':
	// 'column_name', 'value': 'Age'}]
	InsightParameters param.Field[[]ProjectTestUpdateParamsPayloadsThresholdsInsightParameter] `json:"insightParameters"`
	// The measurement to be evaluated.
	Measurement param.Field[string] `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator param.Field[ProjectTestUpdateParamsPayloadsThresholdsOperator] `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode param.Field[ProjectTestUpdateParamsPayloadsThresholdsThresholdMode] `json:"thresholdMode"`
	// The value to be compared.
	Value param.Field[ProjectTestUpdateParamsPayloadsThresholdsValueUnion] `json:"value"`
}

func (ProjectTestUpdateParamsPayloadsThreshold) MarshalJSON 

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

type ProjectTestUpdateParamsPayloadsThresholdsInsightName 

type ProjectTestUpdateParamsPayloadsThresholdsInsightName string

The insight name to be evaluated. 

const (
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameCharacterLength            ProjectTestUpdateParamsPayloadsThresholdsInsightName = "characterLength"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameClassImbalance             ProjectTestUpdateParamsPayloadsThresholdsInsightName = "classImbalance"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameExpectColumnAToBeInColumnB ProjectTestUpdateParamsPayloadsThresholdsInsightName = "expectColumnAToBeInColumnB"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameColumnAverage              ProjectTestUpdateParamsPayloadsThresholdsInsightName = "columnAverage"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameColumnDrift                ProjectTestUpdateParamsPayloadsThresholdsInsightName = "columnDrift"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameColumnValuesMatch          ProjectTestUpdateParamsPayloadsThresholdsInsightName = "columnValuesMatch"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameConfidenceDistribution     ProjectTestUpdateParamsPayloadsThresholdsInsightName = "confidenceDistribution"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameConflictingLabelRowCount   ProjectTestUpdateParamsPayloadsThresholdsInsightName = "conflictingLabelRowCount"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameContainsPii                ProjectTestUpdateParamsPayloadsThresholdsInsightName = "containsPii"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameContainsValidURL           ProjectTestUpdateParamsPayloadsThresholdsInsightName = "containsValidUrl"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameCorrelatedFeatures         ProjectTestUpdateParamsPayloadsThresholdsInsightName = "correlatedFeatures"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameCustomMetric               ProjectTestUpdateParamsPayloadsThresholdsInsightName = "customMetric"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameDuplicateRowCount          ProjectTestUpdateParamsPayloadsThresholdsInsightName = "duplicateRowCount"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameEmptyFeatures              ProjectTestUpdateParamsPayloadsThresholdsInsightName = "emptyFeatures"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameFeatureDrift               ProjectTestUpdateParamsPayloadsThresholdsInsightName = "featureDrift"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameFeatureProfile             ProjectTestUpdateParamsPayloadsThresholdsInsightName = "featureProfile"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameGreatExpectations          ProjectTestUpdateParamsPayloadsThresholdsInsightName = "greatExpectations"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameGroupByColumnStatsCheck    ProjectTestUpdateParamsPayloadsThresholdsInsightName = "groupByColumnStatsCheck"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameIllFormedRowCount          ProjectTestUpdateParamsPayloadsThresholdsInsightName = "illFormedRowCount"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameIsCode                     ProjectTestUpdateParamsPayloadsThresholdsInsightName = "isCode"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameIsJson                     ProjectTestUpdateParamsPayloadsThresholdsInsightName = "isJson"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameLlmRubricV2                ProjectTestUpdateParamsPayloadsThresholdsInsightName = "llmRubricV2"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameLabelDrift                 ProjectTestUpdateParamsPayloadsThresholdsInsightName = "labelDrift"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameMetrics                    ProjectTestUpdateParamsPayloadsThresholdsInsightName = "metrics"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameNewCategories              ProjectTestUpdateParamsPayloadsThresholdsInsightName = "newCategories"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameNewLabels                  ProjectTestUpdateParamsPayloadsThresholdsInsightName = "newLabels"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameNullRowCount               ProjectTestUpdateParamsPayloadsThresholdsInsightName = "nullRowCount"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNamePpScore                    ProjectTestUpdateParamsPayloadsThresholdsInsightName = "ppScore"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameQuasiConstantFeatures      ProjectTestUpdateParamsPayloadsThresholdsInsightName = "quasiConstantFeatures"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameSentenceLength             ProjectTestUpdateParamsPayloadsThresholdsInsightName = "sentenceLength"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameSizeRatio                  ProjectTestUpdateParamsPayloadsThresholdsInsightName = "sizeRatio"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameSpecialCharacters          ProjectTestUpdateParamsPayloadsThresholdsInsightName = "specialCharacters"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameStringValidation           ProjectTestUpdateParamsPayloadsThresholdsInsightName = "stringValidation"
	ProjectTestUpdateParamsPayloadsThresholdsInsightNameTrainValLeakageRowCount    ProjectTestUpdateParamsPayloadsThresholdsInsightName = "trainValLeakageRowCount"
)

func (ProjectTestUpdateParamsPayloadsThresholdsInsightName) IsKnown 

func (r ProjectTestUpdateParamsPayloadsThresholdsInsightName) IsKnown() bool

type ProjectTestUpdateParamsPayloadsThresholdsInsightParameter 

type ProjectTestUpdateParamsPayloadsThresholdsInsightParameter struct {
	// The name of the insight filter.
	Name  param.Field[string]      `json:"name,required"`
	Value param.Field[interface{}] `json:"value,required"`
}

func (ProjectTestUpdateParamsPayloadsThresholdsInsightParameter) MarshalJSON 

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

type ProjectTestUpdateParamsPayloadsThresholdsOperator 

type ProjectTestUpdateParamsPayloadsThresholdsOperator string

The operator to be used for the evaluation. 

const (
	ProjectTestUpdateParamsPayloadsThresholdsOperatorIs              ProjectTestUpdateParamsPayloadsThresholdsOperator = "is"
	ProjectTestUpdateParamsPayloadsThresholdsOperatorGreater         ProjectTestUpdateParamsPayloadsThresholdsOperator = ">"
	ProjectTestUpdateParamsPayloadsThresholdsOperatorGreaterOrEquals ProjectTestUpdateParamsPayloadsThresholdsOperator = ">="
	ProjectTestUpdateParamsPayloadsThresholdsOperatorLess            ProjectTestUpdateParamsPayloadsThresholdsOperator = "<"
	ProjectTestUpdateParamsPayloadsThresholdsOperatorLessOrEquals    ProjectTestUpdateParamsPayloadsThresholdsOperator = "<="
	ProjectTestUpdateParamsPayloadsThresholdsOperatorNotEquals       ProjectTestUpdateParamsPayloadsThresholdsOperator = "!="
)

func (ProjectTestUpdateParamsPayloadsThresholdsOperator) IsKnown 

func (r ProjectTestUpdateParamsPayloadsThresholdsOperator) IsKnown() bool

type ProjectTestUpdateParamsPayloadsThresholdsThresholdMode 

type ProjectTestUpdateParamsPayloadsThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	ProjectTestUpdateParamsPayloadsThresholdsThresholdModeAutomatic ProjectTestUpdateParamsPayloadsThresholdsThresholdMode = "automatic"
	ProjectTestUpdateParamsPayloadsThresholdsThresholdModeManual    ProjectTestUpdateParamsPayloadsThresholdsThresholdMode = "manual"
)

func (ProjectTestUpdateParamsPayloadsThresholdsThresholdMode) IsKnown 

func (r ProjectTestUpdateParamsPayloadsThresholdsThresholdMode) IsKnown() bool

type ProjectTestUpdateParamsPayloadsThresholdsValueArray 

type ProjectTestUpdateParamsPayloadsThresholdsValueArray []string

func (ProjectTestUpdateParamsPayloadsThresholdsValueArray) ImplementsProjectTestUpdateParamsPayloadsThresholdsValueUnion 

func (r ProjectTestUpdateParamsPayloadsThresholdsValueArray) ImplementsProjectTestUpdateParamsPayloadsThresholdsValueUnion()

type ProjectTestUpdateParamsPayloadsThresholdsValueUnion 

type ProjectTestUpdateParamsPayloadsThresholdsValueUnion interface {
	ImplementsProjectTestUpdateParamsPayloadsThresholdsValueUnion()
}

The value to be compared.

Satisfied by shared.UnionFloat, shared.UnionBool, shared.UnionString, ProjectTestUpdateParamsPayloadsThresholdsValueArray.

type ProjectTestUpdateResponse 

type ProjectTestUpdateResponse struct {
	TaskResultID  string                        `json:"taskResultId"`
	TaskResultURL string                        `json:"taskResultUrl"`
	JSON          projectTestUpdateResponseJSON `json:"-"`
}

func (*ProjectTestUpdateResponse) UnmarshalJSON 

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

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.