openlayer

package module
v0.4.5 Latest Latest
Warning

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

 Go to latest Published: Feb 25, 2026 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/[email protected]'

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
	Workspaces         *WorkspaceService
	Commits            *CommitService
	InferencePipelines *InferencePipelineService
	Storage            *StorageService
	Tests              *TestService
}

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" api:"required" format:"uuid"`
	// The details of a commit (project version).
	Commit CommitGetResponseCommit `json:"commit" api:"required"`
	// The commit archive date.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The project version (commit) creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The number of tests that are failing for the commit.
	FailingGoalCount int64 `json:"failingGoalCount" api:"required"`
	// The model id.
	MlModelID string `json:"mlModelId" api:"required,nullable" format:"uuid"`
	// The number of tests that are passing for the commit.
	PassingGoalCount int64 `json:"passingGoalCount" api:"required"`
	// The project id.
	ProjectID string `json:"projectId" api:"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" api:"required"`
	// The commit status message.
	StatusMessage string `json:"statusMessage" api:"required,nullable"`
	// The total number of tests for the commit.
	TotalGoalCount int64 `json:"totalGoalCount" api:"required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId" api:"required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId" api:"required,nullable" format:"uuid"`
	// Whether the commit is archived.
	Archived bool `json:"archived" api:"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" api:"required" format:"uuid"`
	// The author id of the commit.
	AuthorID string `json:"authorId" api:"required" format:"uuid"`
	// The size of the commit bundle in bytes.
	FileSize int64 `json:"fileSize" api:"required,nullable"`
	// The commit message.
	Message string `json:"message" api:"required"`
	// The model id.
	MlModelID string `json:"mlModelId" api:"required,nullable" format:"uuid"`
	// The storage URI where the commit bundle is stored.
	StorageUri string `json:"storageUri" api:"required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId" api:"required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId" api:"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" api:"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" api:"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" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The data end date.
	DateDataEnds time.Time `json:"dateDataEnds" api:"required,nullable" format:"date-time"`
	// The data start date.
	DateDataStarts time.Time `json:"dateDataStarts" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline id.
	InferencePipelineID string `json:"inferencePipelineId" api:"required,nullable" format:"uuid"`
	// The project version (commit) id.
	ProjectVersionID string `json:"projectVersionId" api:"required,nullable" format:"uuid"`
	// The status of the test.
	Status CommitTestResultListResponseItemsStatus `json:"status" api:"required"`
	// The status message.
	StatusMessage  string                                           `json:"statusMessage" api:"required,nullable"`
	ExpectedValues []CommitTestResultListResponseItemsExpectedValue `json:"expectedValues"`
	Goal           CommitTestResultListResponseItemsGoal            `json:"goal"`
	// The test id.
	GoalID string `json:"goalId" api:"nullable" format:"uuid"`
	// The URL to the rows of the test result.
	Rows string `json:"rows"`
	// The body of the rows request.
	RowsBody CommitTestResultListResponseItemsRowsBody `json:"rowsBody" api:"nullable"`
	JSON     commitTestResultListResponseItemJSON      `json:"-"`
}

func (*CommitTestResultListResponseItem) UnmarshalJSON 

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

type CommitTestResultListResponseItemsExpectedValue added in v0.4.0 

type CommitTestResultListResponseItemsExpectedValue struct {
	// the lower threshold for the expected value
	LowerThreshold float64 `json:"lowerThreshold" api:"nullable"`
	// One of the `measurement` values in the test's thresholds
	Measurement string `json:"measurement"`
	// The upper threshold for the expected value
	UpperThreshold float64                                            `json:"upperThreshold" api:"nullable"`
	JSON           commitTestResultListResponseItemsExpectedValueJSON `json:"-"`
}

func (*CommitTestResultListResponseItemsExpectedValue) UnmarshalJSON added in v0.4.0 

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

type CommitTestResultListResponseItemsGoal 

type CommitTestResultListResponseItemsGoal struct {
	// The test id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount" api:"required"`
	// The test creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description" api:"required,nullable"`
	// The test name.
	Name string `json:"name" api:"required"`
	// The test number.
	Number int64 `json:"number" api:"required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId" api:"required,nullable" format:"uuid"`
	// The test subtype.
	Subtype CommitTestResultListResponseItemsGoalSubtype `json:"subtype" api:"required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                             `json:"suggested" api:"required"`
	Thresholds []CommitTestResultListResponseItemsGoalThreshold `json:"thresholds" api:"required"`
	// The test type.
	Type CommitTestResultListResponseItemsGoalType `json:"type" api:"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" api:"nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow" api:"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" api:"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" api:"required"`
	Value interface{}                                                         `json:"value" api:"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 CommitTestResultListResponseItemsRowsBody added in v0.4.0 

type CommitTestResultListResponseItemsRowsBody struct {
	ColumnFilters     []CommitTestResultListResponseItemsRowsBodyColumnFilter `json:"columnFilters" api:"nullable"`
	ExcludeRowIDList  []int64                                                 `json:"excludeRowIdList" api:"nullable"`
	NotSearchQueryAnd []string                                                `json:"notSearchQueryAnd" api:"nullable"`
	NotSearchQueryOr  []string                                                `json:"notSearchQueryOr" api:"nullable"`
	RowIDList         []int64                                                 `json:"rowIdList" api:"nullable"`
	SearchQueryAnd    []string                                                `json:"searchQueryAnd" api:"nullable"`
	SearchQueryOr     []string                                                `json:"searchQueryOr" api:"nullable"`
	JSON              commitTestResultListResponseItemsRowsBodyJSON           `json:"-"`
}

The body of the rows request.

func (*CommitTestResultListResponseItemsRowsBody) UnmarshalJSON added in v0.4.0 

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

type CommitTestResultListResponseItemsRowsBodyColumnFilter added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFilter struct {
	// The name of the column.
	Measurement string                                                         `json:"measurement" api:"required"`
	Operator    CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator `json:"operator" api:"required"`
	// This field can have the runtime type of
	// [[]CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion],
	// [float64],
	// [CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion].
	Value interface{}                                               `json:"value" api:"required"`
	JSON  commitTestResultListResponseItemsRowsBodyColumnFilterJSON `json:"-"`
	// contains filtered or unexported fields
}

func (CommitTestResultListResponseItemsRowsBodyColumnFilter) AsUnion added in v0.4.0 

func (r CommitTestResultListResponseItemsRowsBodyColumnFilter) AsUnion() CommitTestResultListResponseItemsRowsBodyColumnFiltersUnion

AsUnion returns a CommitTestResultListResponseItemsRowsBodyColumnFiltersUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter, CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter, CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter.

func (*CommitTestResultListResponseItemsRowsBodyColumnFilter) UnmarshalJSON added in v0.4.0 

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

type CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter struct {
	// The name of the column.
	Measurement string                                                                            `json:"measurement" api:"required"`
	Operator    CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator `json:"operator" api:"required"`
	Value       float64                                                                           `json:"value" api:"required,nullable"`
	JSON        commitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterJSON     `json:"-"`
}

func (*CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter) UnmarshalJSON added in v0.4.0 

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

type CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator string
const (
	CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorGreater         CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = ">"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorGreaterOrEquals CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = ">="
	CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorIs              CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "is"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorLess            CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "<"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorLessOrEquals    CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "<="
	CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorNotEquals       CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "!="
)

func (CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown added in v0.4.0 

func (r CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown() bool

type CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator string
const (
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorContainsNone    CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "contains_none"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorContainsAny     CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "contains_any"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorContainsAll     CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "contains_all"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorOneOf           CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "one_of"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorNoneOf          CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "none_of"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorGreater         CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = ">"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorGreaterOrEquals CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = ">="
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorIs              CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "is"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorLess            CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "<"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorLessOrEquals    CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "<="
	CommitTestResultListResponseItemsRowsBodyColumnFiltersOperatorNotEquals       CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator = "!="
)

func (CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator) IsKnown added in v0.4.0 

func (r CommitTestResultListResponseItemsRowsBodyColumnFiltersOperator) IsKnown() bool

type CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter struct {
	// The name of the column.
	Measurement string                                                                            `json:"measurement" api:"required"`
	Operator    CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator     `json:"operator" api:"required"`
	Value       []CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion `json:"value" api:"required"`
	JSON        commitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterJSON         `json:"-"`
}

func (*CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter) UnmarshalJSON added in v0.4.0 

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

type CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator string
const (
	CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsNone CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_none"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsAny  CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_any"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsAll  CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_all"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorOneOf        CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "one_of"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorNoneOf       CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "none_of"
)

func (CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown added in v0.4.0 

func (r CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown() bool

type CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion interface {
	ImplementsCommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionFloat.

type CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter struct {
	// The name of the column.
	Measurement string                                                                             `json:"measurement" api:"required"`
	Operator    CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator   `json:"operator" api:"required"`
	Value       CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion `json:"value" api:"required"`
	JSON        commitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterJSON       `json:"-"`
}

func (*CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter) UnmarshalJSON added in v0.4.0 

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

type CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator string
const (
	CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperatorIs        CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator = "is"
	CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperatorNotEquals CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator = "!="
)

func (CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown added in v0.4.0 

func (r CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown() bool

type CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion added in v0.4.0 

type CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion interface {
	ImplementsCommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionBool.

type CommitTestResultListResponseItemsRowsBodyColumnFiltersUnion added in v0.4.0 

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

Union satisfied by CommitTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter, CommitTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter or CommitTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter.

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" api:"required"`
	// A list of inference data points with inputs and outputs
	Rows param.Field[[]map[string]interface{}] `json:"rows" api:"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" api:"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" api:"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" api:"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" api:"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" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated" api:"required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived" api:"required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description" api:"required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                             `json:"failingGoalCount" api:"required"`
	Links            InferencePipelineGetResponseLinks `json:"links" api:"required"`
	// The inference pipeline name.
	Name string `json:"name" api:"required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount" api:"required"`
	// The project id.
	ProjectID string `json:"projectId" api:"required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status InferencePipelineGetResponseStatus `json:"status" api:"required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage" api:"required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                   `json:"totalGoalCount" api:"required"`
	DataBackend    InferencePipelineGetResponseDataBackend `json:"dataBackend" api:"nullable"`
	// The last time the data was polled.
	DateLastPolled time.Time                           `json:"dateLastPolled" api:"nullable" format:"date-time"`
	Project        InferencePipelineGetResponseProject `json:"project" api:"nullable"`
	// The total number of records in the data backend.
	TotalRecordsCount int64                                 `json:"totalRecordsCount" api:"nullable"`
	Workspace         InferencePipelineGetResponseWorkspace `json:"workspace" api:"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 InferencePipelineGetResponseDataBackend added in v0.2.0 

type InferencePipelineGetResponseDataBackend struct {
	BackendType          InferencePipelineGetResponseDataBackendBackendType `json:"backendType" api:"required"`
	BigqueryConnectionID string                                             `json:"bigqueryConnectionId" api:"nullable" format:"uuid"`
	// This field can have the runtime type of
	// [InferencePipelineGetResponseDataBackendBigQueryDataBackendConfig],
	// [InferencePipelineGetResponseDataBackendSnowflakeDataBackendConfig],
	// [InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendConfig],
	// [InferencePipelineGetResponseDataBackendRedshiftDataBackendConfig],
	// [InferencePipelineGetResponseDataBackendPostgresDataBackendConfig].
	Config                    interface{}                                          `json:"config"`
	Database                  string                                               `json:"database"`
	DatabricksDtlConnectionID string                                               `json:"databricksDtlConnectionId" api:"nullable" format:"uuid"`
	DatasetID                 string                                               `json:"datasetId"`
	PartitionType             InferencePipelineGetResponseDataBackendPartitionType `json:"partitionType" api:"nullable"`
	PostgresConnectionID      string                                               `json:"postgresConnectionId" api:"nullable" format:"uuid"`
	ProjectID                 string                                               `json:"projectId"`
	RedshiftConnectionID      string                                               `json:"redshiftConnectionId" api:"nullable" format:"uuid"`
	Schema                    string                                               `json:"schema"`
	SchemaName                string                                               `json:"schemaName"`
	SnowflakeConnectionID     string                                               `json:"snowflakeConnectionId" api:"nullable" format:"uuid"`
	Table                     string                                               `json:"table" api:"nullable"`
	TableID                   string                                               `json:"tableId" api:"nullable"`
	TableName                 string                                               `json:"tableName"`
	JSON                      inferencePipelineGetResponseDataBackendJSON          `json:"-"`
	// contains filtered or unexported fields
}

func (InferencePipelineGetResponseDataBackend) AsUnion added in v0.2.0 

func (r InferencePipelineGetResponseDataBackend) AsUnion() InferencePipelineGetResponseDataBackendUnion

AsUnion returns a InferencePipelineGetResponseDataBackendUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are InferencePipelineGetResponseDataBackendBigQueryDataBackend, InferencePipelineGetResponseDataBackendDefaultDataBackend, InferencePipelineGetResponseDataBackendSnowflakeDataBackend, InferencePipelineGetResponseDataBackendDatabricksDtlDataBackend, InferencePipelineGetResponseDataBackendRedshiftDataBackend, InferencePipelineGetResponseDataBackendPostgresDataBackend.

func (*InferencePipelineGetResponseDataBackend) UnmarshalJSON added in v0.2.0 

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

type InferencePipelineGetResponseDataBackendBackendType added in v0.2.0 

type InferencePipelineGetResponseDataBackendBackendType string
const (
	InferencePipelineGetResponseDataBackendBackendTypeBigquery      InferencePipelineGetResponseDataBackendBackendType = "bigquery"
	InferencePipelineGetResponseDataBackendBackendTypeDefault       InferencePipelineGetResponseDataBackendBackendType = "default"
	InferencePipelineGetResponseDataBackendBackendTypeSnowflake     InferencePipelineGetResponseDataBackendBackendType = "snowflake"
	InferencePipelineGetResponseDataBackendBackendTypeDatabricksDtl InferencePipelineGetResponseDataBackendBackendType = "databricks_dtl"
	InferencePipelineGetResponseDataBackendBackendTypeRedshift      InferencePipelineGetResponseDataBackendBackendType = "redshift"
	InferencePipelineGetResponseDataBackendBackendTypePostgres      InferencePipelineGetResponseDataBackendBackendType = "postgres"
)

func (InferencePipelineGetResponseDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendBackendType) IsKnown() bool

type InferencePipelineGetResponseDataBackendBigQueryDataBackend added in v0.3.1 

type InferencePipelineGetResponseDataBackendBigQueryDataBackend struct {
	BackendType          InferencePipelineGetResponseDataBackendBigQueryDataBackendBackendType   `json:"backendType" api:"required"`
	BigqueryConnectionID string                                                                  `json:"bigqueryConnectionId" api:"required,nullable" format:"uuid"`
	DatasetID            string                                                                  `json:"datasetId" api:"required"`
	ProjectID            string                                                                  `json:"projectId" api:"required"`
	TableID              string                                                                  `json:"tableId" api:"required,nullable"`
	PartitionType        InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType `json:"partitionType" api:"nullable"`
	JSON                 inferencePipelineGetResponseDataBackendBigQueryDataBackendJSON          `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendBigQueryDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendBigQueryDataBackendBackendType added in v0.3.1 

type InferencePipelineGetResponseDataBackendBigQueryDataBackendBackendType string
const (
	InferencePipelineGetResponseDataBackendBigQueryDataBackendBackendTypeBigquery InferencePipelineGetResponseDataBackendBigQueryDataBackendBackendType = "bigquery"
)

func (InferencePipelineGetResponseDataBackendBigQueryDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendBigQueryDataBackendBackendType) IsKnown() bool

type InferencePipelineGetResponseDataBackendBigQueryDataBackendConfig added in v0.3.1 

type InferencePipelineGetResponseDataBackendBigQueryDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                               `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineGetResponseDataBackendBigQueryDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendBigQueryDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType added in v0.3.1 

type InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType string
const (
	InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionTypeDay   InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType = "DAY"
	InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionTypeMonth InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType = "MONTH"
	InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionTypeYear  InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType = "YEAR"
)

func (InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendBigQueryDataBackendPartitionType) IsKnown() bool

type InferencePipelineGetResponseDataBackendDatabricksDtlDataBackend added in v0.3.1 

type InferencePipelineGetResponseDataBackendDatabricksDtlDataBackend struct {
	BackendType               InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendBackendType `json:"backendType" api:"required"`
	DatabricksDtlConnectionID string                                                                     `json:"databricksDtlConnectionId" api:"required,nullable" format:"uuid"`
	TableID                   string                                                                     `json:"tableId" api:"required,nullable"`
	JSON                      inferencePipelineGetResponseDataBackendDatabricksDtlDataBackendJSON        `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendDatabricksDtlDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendBackendType added in v0.3.1 

type InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendBackendType string
const (
	InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendBackendTypeDatabricksDtl InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendBackendType = "databricks_dtl"
)

func (InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendBackendType) IsKnown() bool

type InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendConfig added in v0.3.1 

type InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                    `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineGetResponseDataBackendDatabricksDtlDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendDatabricksDtlDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendDefaultDataBackend added in v0.3.1 

type InferencePipelineGetResponseDataBackendDefaultDataBackend struct {
	BackendType InferencePipelineGetResponseDataBackendDefaultDataBackendBackendType `json:"backendType" api:"required"`
	JSON        inferencePipelineGetResponseDataBackendDefaultDataBackendJSON        `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendDefaultDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendDefaultDataBackendBackendType added in v0.3.1 

type InferencePipelineGetResponseDataBackendDefaultDataBackendBackendType string
const (
	InferencePipelineGetResponseDataBackendDefaultDataBackendBackendTypeDefault InferencePipelineGetResponseDataBackendDefaultDataBackendBackendType = "default"
)

func (InferencePipelineGetResponseDataBackendDefaultDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendDefaultDataBackendBackendType) IsKnown() bool

type InferencePipelineGetResponseDataBackendPartitionType added in v0.2.0 

type InferencePipelineGetResponseDataBackendPartitionType string
const (
	InferencePipelineGetResponseDataBackendPartitionTypeDay   InferencePipelineGetResponseDataBackendPartitionType = "DAY"
	InferencePipelineGetResponseDataBackendPartitionTypeMonth InferencePipelineGetResponseDataBackendPartitionType = "MONTH"
	InferencePipelineGetResponseDataBackendPartitionTypeYear  InferencePipelineGetResponseDataBackendPartitionType = "YEAR"
)

func (InferencePipelineGetResponseDataBackendPartitionType) IsKnown added in v0.2.0 

func (r InferencePipelineGetResponseDataBackendPartitionType) IsKnown() bool

type InferencePipelineGetResponseDataBackendPostgresDataBackend added in v0.3.1 

type InferencePipelineGetResponseDataBackendPostgresDataBackend struct {
	BackendType          InferencePipelineGetResponseDataBackendPostgresDataBackendBackendType `json:"backendType" api:"required"`
	Database             string                                                                `json:"database" api:"required"`
	PostgresConnectionID string                                                                `json:"postgresConnectionId" api:"required,nullable" format:"uuid"`
	Schema               string                                                                `json:"schema" api:"required"`
	Table                string                                                                `json:"table" api:"required,nullable"`
	JSON                 inferencePipelineGetResponseDataBackendPostgresDataBackendJSON        `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendPostgresDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendPostgresDataBackendBackendType added in v0.3.1 

type InferencePipelineGetResponseDataBackendPostgresDataBackendBackendType string
const (
	InferencePipelineGetResponseDataBackendPostgresDataBackendBackendTypePostgres InferencePipelineGetResponseDataBackendPostgresDataBackendBackendType = "postgres"
)

func (InferencePipelineGetResponseDataBackendPostgresDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendPostgresDataBackendBackendType) IsKnown() bool

type InferencePipelineGetResponseDataBackendPostgresDataBackendConfig added in v0.3.1 

type InferencePipelineGetResponseDataBackendPostgresDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                               `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineGetResponseDataBackendPostgresDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendPostgresDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendRedshiftDataBackend added in v0.3.1 

type InferencePipelineGetResponseDataBackendRedshiftDataBackend struct {
	BackendType          InferencePipelineGetResponseDataBackendRedshiftDataBackendBackendType `json:"backendType" api:"required"`
	RedshiftConnectionID string                                                                `json:"redshiftConnectionId" api:"required,nullable" format:"uuid"`
	SchemaName           string                                                                `json:"schemaName" api:"required"`
	TableName            string                                                                `json:"tableName" api:"required"`
	JSON                 inferencePipelineGetResponseDataBackendRedshiftDataBackendJSON        `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendRedshiftDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendRedshiftDataBackendBackendType added in v0.3.1 

type InferencePipelineGetResponseDataBackendRedshiftDataBackendBackendType string
const (
	InferencePipelineGetResponseDataBackendRedshiftDataBackendBackendTypeRedshift InferencePipelineGetResponseDataBackendRedshiftDataBackendBackendType = "redshift"
)

func (InferencePipelineGetResponseDataBackendRedshiftDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendRedshiftDataBackendBackendType) IsKnown() bool

type InferencePipelineGetResponseDataBackendRedshiftDataBackendConfig added in v0.3.1 

type InferencePipelineGetResponseDataBackendRedshiftDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                               `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineGetResponseDataBackendRedshiftDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendRedshiftDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendSnowflakeDataBackend added in v0.3.1 

type InferencePipelineGetResponseDataBackendSnowflakeDataBackend struct {
	BackendType           InferencePipelineGetResponseDataBackendSnowflakeDataBackendBackendType `json:"backendType" api:"required"`
	Database              string                                                                 `json:"database" api:"required"`
	Schema                string                                                                 `json:"schema" api:"required"`
	SnowflakeConnectionID string                                                                 `json:"snowflakeConnectionId" api:"required,nullable" format:"uuid"`
	Table                 string                                                                 `json:"table" api:"required,nullable"`
	JSON                  inferencePipelineGetResponseDataBackendSnowflakeDataBackendJSON        `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendSnowflakeDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendSnowflakeDataBackendBackendType added in v0.3.1 

type InferencePipelineGetResponseDataBackendSnowflakeDataBackendBackendType string
const (
	InferencePipelineGetResponseDataBackendSnowflakeDataBackendBackendTypeSnowflake InferencePipelineGetResponseDataBackendSnowflakeDataBackendBackendType = "snowflake"
)

func (InferencePipelineGetResponseDataBackendSnowflakeDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineGetResponseDataBackendSnowflakeDataBackendBackendType) IsKnown() bool

type InferencePipelineGetResponseDataBackendSnowflakeDataBackendConfig added in v0.3.1 

type InferencePipelineGetResponseDataBackendSnowflakeDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineGetResponseDataBackendSnowflakeDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineGetResponseDataBackendSnowflakeDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineGetResponseDataBackendUnion added in v0.2.0 

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

Union satisfied by InferencePipelineGetResponseDataBackendBigQueryDataBackend, InferencePipelineGetResponseDataBackendDefaultDataBackend, InferencePipelineGetResponseDataBackendSnowflakeDataBackend, InferencePipelineGetResponseDataBackendDatabricksDtlDataBackend, InferencePipelineGetResponseDataBackendRedshiftDataBackend or InferencePipelineGetResponseDataBackendPostgresDataBackend. 

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

func (*InferencePipelineGetResponseProject) UnmarshalJSON 

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

type InferencePipelineGetResponseProjectGitRepo 

type InferencePipelineGetResponseProjectGitRepo struct {
	ID            string                                         `json:"id" api:"required" format:"uuid"`
	DateConnected time.Time                                      `json:"dateConnected" api:"required" format:"date-time"`
	DateUpdated   time.Time                                      `json:"dateUpdated" api:"required" format:"date-time"`
	GitAccountID  string                                         `json:"gitAccountId" api:"required" format:"uuid"`
	GitID         int64                                          `json:"gitId" api:"required"`
	Name          string                                         `json:"name" api:"required"`
	Private       bool                                           `json:"private" api:"required"`
	ProjectID     string                                         `json:"projectId" api:"required" format:"uuid"`
	Slug          string                                         `json:"slug" api:"required"`
	URL           string                                         `json:"url" api:"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" api:"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" api:"required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount" api:"required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount" api:"required"`
	// The workspace name.
	Name string `json:"name" api:"required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate" api:"required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate" api:"required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount" api:"required"`
	// The workspace slug.
	Slug         string                                              `json:"slug" api:"required"`
	Status       InferencePipelineGetResponseWorkspaceStatus         `json:"status" api:"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" api:"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 InferencePipelineGetUsersParams added in v0.4.3 

type InferencePipelineGetUsersParams 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 (InferencePipelineGetUsersParams) URLQuery added in v0.4.3 

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

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

type InferencePipelineGetUsersResponse added in v0.4.3 

type InferencePipelineGetUsersResponse struct {
	// Array of user aggregation data
	Items []InferencePipelineGetUsersResponseItem `json:"items" api:"required"`
	JSON  inferencePipelineGetUsersResponseJSON   `json:"-"`
}

func (*InferencePipelineGetUsersResponse) UnmarshalJSON added in v0.4.3 

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

type InferencePipelineGetUsersResponseItem added in v0.4.3 

type InferencePipelineGetUsersResponseItem struct {
	// The unique user identifier
	ID string `json:"id" api:"required"`
	// Total cost for this user
	Cost float64 `json:"cost" api:"required"`
	// Timestamp of the user's first event/trace
	DateOfFirstRecord time.Time `json:"dateOfFirstRecord" api:"required" format:"date-time"`
	// Timestamp of the user's last event/trace
	DateOfLastRecord time.Time `json:"dateOfLastRecord" api:"required" format:"date-time"`
	// Total number of traces/rows for this user
	Records int64 `json:"records" api:"required"`
	// Count of unique sessions for this user
	Sessions int64 `json:"sessions" api:"required"`
	// Total token count for this user
	Tokens float64                                   `json:"tokens" api:"required"`
	JSON   inferencePipelineGetUsersResponseItemJSON `json:"-"`
}

func (*InferencePipelineGetUsersResponseItem) UnmarshalJSON added in v0.4.3 

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

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" api:"required"`
	Row         param.Field[interface{}]                            `json:"row" api:"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" api:"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) GetUsers added in v0.4.3 

func (r *InferencePipelineService) GetUsers(ctx context.Context, inferencePipelineID string, query InferencePipelineGetUsersParams, opts ...option.RequestOption) (res *InferencePipelineGetUsersResponse, err error)

Get aggregated user data for an inference pipeline with pagination and metadata.

Returns a list of users who have interacted with the inference pipeline, including their activity statistics such as session counts, record counts, token usage, and costs.

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" api:"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" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The data end date.
	DateDataEnds time.Time `json:"dateDataEnds" api:"required,nullable" format:"date-time"`
	// The data start date.
	DateDataStarts time.Time `json:"dateDataStarts" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline id.
	InferencePipelineID string `json:"inferencePipelineId" api:"required,nullable" format:"uuid"`
	// The project version (commit) id.
	ProjectVersionID string `json:"projectVersionId" api:"required,nullable" format:"uuid"`
	// The status of the test.
	Status InferencePipelineTestResultListResponseItemsStatus `json:"status" api:"required"`
	// The status message.
	StatusMessage  string                                                      `json:"statusMessage" api:"required,nullable"`
	ExpectedValues []InferencePipelineTestResultListResponseItemsExpectedValue `json:"expectedValues"`
	Goal           InferencePipelineTestResultListResponseItemsGoal            `json:"goal"`
	// The test id.
	GoalID string `json:"goalId" api:"nullable" format:"uuid"`
	// The URL to the rows of the test result.
	Rows string `json:"rows"`
	// The body of the rows request.
	RowsBody InferencePipelineTestResultListResponseItemsRowsBody `json:"rowsBody" api:"nullable"`
	JSON     inferencePipelineTestResultListResponseItemJSON      `json:"-"`
}

func (*InferencePipelineTestResultListResponseItem) UnmarshalJSON 

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

type InferencePipelineTestResultListResponseItemsExpectedValue added in v0.4.0 

type InferencePipelineTestResultListResponseItemsExpectedValue struct {
	// the lower threshold for the expected value
	LowerThreshold float64 `json:"lowerThreshold" api:"nullable"`
	// One of the `measurement` values in the test's thresholds
	Measurement string `json:"measurement"`
	// The upper threshold for the expected value
	UpperThreshold float64                                                       `json:"upperThreshold" api:"nullable"`
	JSON           inferencePipelineTestResultListResponseItemsExpectedValueJSON `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsExpectedValue) UnmarshalJSON added in v0.4.0 

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

type InferencePipelineTestResultListResponseItemsGoal 

type InferencePipelineTestResultListResponseItemsGoal struct {
	// The test id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount" api:"required"`
	// The test creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description" api:"required,nullable"`
	// The test name.
	Name string `json:"name" api:"required"`
	// The test number.
	Number int64 `json:"number" api:"required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId" api:"required,nullable" format:"uuid"`
	// The test subtype.
	Subtype InferencePipelineTestResultListResponseItemsGoalSubtype `json:"subtype" api:"required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                                        `json:"suggested" api:"required"`
	Thresholds []InferencePipelineTestResultListResponseItemsGoalThreshold `json:"thresholds" api:"required"`
	// The test type.
	Type InferencePipelineTestResultListResponseItemsGoalType `json:"type" api:"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" api:"nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow" api:"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" api:"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" api:"required"`
	Value interface{}                                                                    `json:"value" api:"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 InferencePipelineTestResultListResponseItemsRowsBody added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBody struct {
	ColumnFilters     []InferencePipelineTestResultListResponseItemsRowsBodyColumnFilter `json:"columnFilters" api:"nullable"`
	ExcludeRowIDList  []int64                                                            `json:"excludeRowIdList" api:"nullable"`
	NotSearchQueryAnd []string                                                           `json:"notSearchQueryAnd" api:"nullable"`
	NotSearchQueryOr  []string                                                           `json:"notSearchQueryOr" api:"nullable"`
	RowIDList         []int64                                                            `json:"rowIdList" api:"nullable"`
	SearchQueryAnd    []string                                                           `json:"searchQueryAnd" api:"nullable"`
	SearchQueryOr     []string                                                           `json:"searchQueryOr" api:"nullable"`
	JSON              inferencePipelineTestResultListResponseItemsRowsBodyJSON           `json:"-"`
}

The body of the rows request.

func (*InferencePipelineTestResultListResponseItemsRowsBody) UnmarshalJSON added in v0.4.0 

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

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFilter added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFilter struct {
	// The name of the column.
	Measurement string                                                                    `json:"measurement" api:"required"`
	Operator    InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator `json:"operator" api:"required"`
	// This field can have the runtime type of
	// [[]InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion],
	// [float64],
	// [InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion].
	Value interface{}                                                          `json:"value" api:"required"`
	JSON  inferencePipelineTestResultListResponseItemsRowsBodyColumnFilterJSON `json:"-"`
	// contains filtered or unexported fields
}

func (InferencePipelineTestResultListResponseItemsRowsBodyColumnFilter) AsUnion added in v0.4.0 

func (r InferencePipelineTestResultListResponseItemsRowsBodyColumnFilter) AsUnion() InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersUnion

AsUnion returns a InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter, InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter, InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter.

func (*InferencePipelineTestResultListResponseItemsRowsBodyColumnFilter) UnmarshalJSON added in v0.4.0 

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

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter struct {
	// The name of the column.
	Measurement string                                                                                       `json:"measurement" api:"required"`
	Operator    InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator `json:"operator" api:"required"`
	Value       float64                                                                                      `json:"value" api:"required,nullable"`
	JSON        inferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterJSON     `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter) UnmarshalJSON added in v0.4.0 

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

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator string
const (
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorGreater         InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = ">"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorGreaterOrEquals InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = ">="
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorIs              InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "is"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorLess            InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "<"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorLessOrEquals    InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "<="
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorNotEquals       InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "!="
)

func (InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown added in v0.4.0 

func (r InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown() bool

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator string
const (
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorContainsNone    InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "contains_none"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorContainsAny     InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "contains_any"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorContainsAll     InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "contains_all"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorOneOf           InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "one_of"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorNoneOf          InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "none_of"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorGreater         InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = ">"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorGreaterOrEquals InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = ">="
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorIs              InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "is"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorLess            InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "<"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorLessOrEquals    InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "<="
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperatorNotEquals       InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator = "!="
)

func (InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator) IsKnown added in v0.4.0 

func (r InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersOperator) IsKnown() bool

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter struct {
	// The name of the column.
	Measurement string                                                                                       `json:"measurement" api:"required"`
	Operator    InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator     `json:"operator" api:"required"`
	Value       []InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion `json:"value" api:"required"`
	JSON        inferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterJSON         `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter) UnmarshalJSON added in v0.4.0 

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

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator string
const (
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsNone InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_none"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsAny  InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_any"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsAll  InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_all"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorOneOf        InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "one_of"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorNoneOf       InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "none_of"
)

func (InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown added in v0.4.0 

func (r InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown() bool

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion interface {
	ImplementsInferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionFloat.

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter struct {
	// The name of the column.
	Measurement string                                                                                        `json:"measurement" api:"required"`
	Operator    InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator   `json:"operator" api:"required"`
	Value       InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion `json:"value" api:"required"`
	JSON        inferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterJSON       `json:"-"`
}

func (*InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter) UnmarshalJSON added in v0.4.0 

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

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator string
const (
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperatorIs        InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator = "is"
	InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperatorNotEquals InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator = "!="
)

func (InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown added in v0.4.0 

func (r InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown() bool

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion added in v0.4.0 

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion interface {
	ImplementsInferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionBool.

type InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersUnion added in v0.4.0 

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

Union satisfied by InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersSetColumnFilter, InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersNumericColumnFilter or InferencePipelineTestResultListResponseItemsRowsBodyColumnFiltersStringColumnFilter.

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" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated" api:"required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived" api:"required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description" api:"required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                                `json:"failingGoalCount" api:"required"`
	Links            InferencePipelineUpdateResponseLinks `json:"links" api:"required"`
	// The inference pipeline name.
	Name string `json:"name" api:"required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount" api:"required"`
	// The project id.
	ProjectID string `json:"projectId" api:"required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status InferencePipelineUpdateResponseStatus `json:"status" api:"required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage" api:"required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                      `json:"totalGoalCount" api:"required"`
	DataBackend    InferencePipelineUpdateResponseDataBackend `json:"dataBackend" api:"nullable"`
	// The last time the data was polled.
	DateLastPolled time.Time                              `json:"dateLastPolled" api:"nullable" format:"date-time"`
	Project        InferencePipelineUpdateResponseProject `json:"project" api:"nullable"`
	// The total number of records in the data backend.
	TotalRecordsCount int64                                    `json:"totalRecordsCount" api:"nullable"`
	Workspace         InferencePipelineUpdateResponseWorkspace `json:"workspace" api:"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 InferencePipelineUpdateResponseDataBackend added in v0.2.0 

type InferencePipelineUpdateResponseDataBackend struct {
	BackendType          InferencePipelineUpdateResponseDataBackendBackendType `json:"backendType" api:"required"`
	BigqueryConnectionID string                                                `json:"bigqueryConnectionId" api:"nullable" format:"uuid"`
	// This field can have the runtime type of
	// [InferencePipelineUpdateResponseDataBackendBigQueryDataBackendConfig],
	// [InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendConfig],
	// [InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendConfig],
	// [InferencePipelineUpdateResponseDataBackendRedshiftDataBackendConfig],
	// [InferencePipelineUpdateResponseDataBackendPostgresDataBackendConfig].
	Config                    interface{}                                             `json:"config"`
	Database                  string                                                  `json:"database"`
	DatabricksDtlConnectionID string                                                  `json:"databricksDtlConnectionId" api:"nullable" format:"uuid"`
	DatasetID                 string                                                  `json:"datasetId"`
	PartitionType             InferencePipelineUpdateResponseDataBackendPartitionType `json:"partitionType" api:"nullable"`
	PostgresConnectionID      string                                                  `json:"postgresConnectionId" api:"nullable" format:"uuid"`
	ProjectID                 string                                                  `json:"projectId"`
	RedshiftConnectionID      string                                                  `json:"redshiftConnectionId" api:"nullable" format:"uuid"`
	Schema                    string                                                  `json:"schema"`
	SchemaName                string                                                  `json:"schemaName"`
	SnowflakeConnectionID     string                                                  `json:"snowflakeConnectionId" api:"nullable" format:"uuid"`
	Table                     string                                                  `json:"table" api:"nullable"`
	TableID                   string                                                  `json:"tableId" api:"nullable"`
	TableName                 string                                                  `json:"tableName"`
	JSON                      inferencePipelineUpdateResponseDataBackendJSON          `json:"-"`
	// contains filtered or unexported fields
}

func (InferencePipelineUpdateResponseDataBackend) AsUnion added in v0.2.0 

func (r InferencePipelineUpdateResponseDataBackend) AsUnion() InferencePipelineUpdateResponseDataBackendUnion

AsUnion returns a InferencePipelineUpdateResponseDataBackendUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are InferencePipelineUpdateResponseDataBackendBigQueryDataBackend, InferencePipelineUpdateResponseDataBackendDefaultDataBackend, InferencePipelineUpdateResponseDataBackendSnowflakeDataBackend, InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackend, InferencePipelineUpdateResponseDataBackendRedshiftDataBackend, InferencePipelineUpdateResponseDataBackendPostgresDataBackend.

func (*InferencePipelineUpdateResponseDataBackend) UnmarshalJSON added in v0.2.0 

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

type InferencePipelineUpdateResponseDataBackendBackendType added in v0.2.0 

type InferencePipelineUpdateResponseDataBackendBackendType string
const (
	InferencePipelineUpdateResponseDataBackendBackendTypeBigquery      InferencePipelineUpdateResponseDataBackendBackendType = "bigquery"
	InferencePipelineUpdateResponseDataBackendBackendTypeDefault       InferencePipelineUpdateResponseDataBackendBackendType = "default"
	InferencePipelineUpdateResponseDataBackendBackendTypeSnowflake     InferencePipelineUpdateResponseDataBackendBackendType = "snowflake"
	InferencePipelineUpdateResponseDataBackendBackendTypeDatabricksDtl InferencePipelineUpdateResponseDataBackendBackendType = "databricks_dtl"
	InferencePipelineUpdateResponseDataBackendBackendTypeRedshift      InferencePipelineUpdateResponseDataBackendBackendType = "redshift"
	InferencePipelineUpdateResponseDataBackendBackendTypePostgres      InferencePipelineUpdateResponseDataBackendBackendType = "postgres"
)

func (InferencePipelineUpdateResponseDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendBackendType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackend added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackend struct {
	BackendType          InferencePipelineUpdateResponseDataBackendBigQueryDataBackendBackendType   `json:"backendType" api:"required"`
	BigqueryConnectionID string                                                                     `json:"bigqueryConnectionId" api:"required,nullable" format:"uuid"`
	DatasetID            string                                                                     `json:"datasetId" api:"required"`
	ProjectID            string                                                                     `json:"projectId" api:"required"`
	TableID              string                                                                     `json:"tableId" api:"required,nullable"`
	PartitionType        InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType `json:"partitionType" api:"nullable"`
	JSON                 inferencePipelineUpdateResponseDataBackendBigQueryDataBackendJSON          `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendBigQueryDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackendBackendType added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackendBackendType string
const (
	InferencePipelineUpdateResponseDataBackendBigQueryDataBackendBackendTypeBigquery InferencePipelineUpdateResponseDataBackendBigQueryDataBackendBackendType = "bigquery"
)

func (InferencePipelineUpdateResponseDataBackendBigQueryDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendBigQueryDataBackendBackendType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackendConfig added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                  `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineUpdateResponseDataBackendBigQueryDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendBigQueryDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType string
const (
	InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionTypeDay   InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType = "DAY"
	InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionTypeMonth InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType = "MONTH"
	InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionTypeYear  InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType = "YEAR"
)

func (InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendBigQueryDataBackendPartitionType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackend added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackend struct {
	BackendType               InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendBackendType `json:"backendType" api:"required"`
	DatabricksDtlConnectionID string                                                                        `json:"databricksDtlConnectionId" api:"required,nullable" format:"uuid"`
	TableID                   string                                                                        `json:"tableId" api:"required,nullable"`
	JSON                      inferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendJSON        `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendBackendType added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendBackendType string
const (
	InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendBackendTypeDatabricksDtl InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendBackendType = "databricks_dtl"
)

func (InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendBackendType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendConfig added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                       `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendDefaultDataBackend added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendDefaultDataBackend struct {
	BackendType InferencePipelineUpdateResponseDataBackendDefaultDataBackendBackendType `json:"backendType" api:"required"`
	JSON        inferencePipelineUpdateResponseDataBackendDefaultDataBackendJSON        `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendDefaultDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendDefaultDataBackendBackendType added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendDefaultDataBackendBackendType string
const (
	InferencePipelineUpdateResponseDataBackendDefaultDataBackendBackendTypeDefault InferencePipelineUpdateResponseDataBackendDefaultDataBackendBackendType = "default"
)

func (InferencePipelineUpdateResponseDataBackendDefaultDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendDefaultDataBackendBackendType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendPartitionType added in v0.2.0 

type InferencePipelineUpdateResponseDataBackendPartitionType string
const (
	InferencePipelineUpdateResponseDataBackendPartitionTypeDay   InferencePipelineUpdateResponseDataBackendPartitionType = "DAY"
	InferencePipelineUpdateResponseDataBackendPartitionTypeMonth InferencePipelineUpdateResponseDataBackendPartitionType = "MONTH"
	InferencePipelineUpdateResponseDataBackendPartitionTypeYear  InferencePipelineUpdateResponseDataBackendPartitionType = "YEAR"
)

func (InferencePipelineUpdateResponseDataBackendPartitionType) IsKnown added in v0.2.0 

func (r InferencePipelineUpdateResponseDataBackendPartitionType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendPostgresDataBackend added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendPostgresDataBackend struct {
	BackendType          InferencePipelineUpdateResponseDataBackendPostgresDataBackendBackendType `json:"backendType" api:"required"`
	Database             string                                                                   `json:"database" api:"required"`
	PostgresConnectionID string                                                                   `json:"postgresConnectionId" api:"required,nullable" format:"uuid"`
	Schema               string                                                                   `json:"schema" api:"required"`
	Table                string                                                                   `json:"table" api:"required,nullable"`
	JSON                 inferencePipelineUpdateResponseDataBackendPostgresDataBackendJSON        `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendPostgresDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendPostgresDataBackendBackendType added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendPostgresDataBackendBackendType string
const (
	InferencePipelineUpdateResponseDataBackendPostgresDataBackendBackendTypePostgres InferencePipelineUpdateResponseDataBackendPostgresDataBackendBackendType = "postgres"
)

func (InferencePipelineUpdateResponseDataBackendPostgresDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendPostgresDataBackendBackendType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendPostgresDataBackendConfig added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendPostgresDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                  `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineUpdateResponseDataBackendPostgresDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendPostgresDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendRedshiftDataBackend added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendRedshiftDataBackend struct {
	BackendType          InferencePipelineUpdateResponseDataBackendRedshiftDataBackendBackendType `json:"backendType" api:"required"`
	RedshiftConnectionID string                                                                   `json:"redshiftConnectionId" api:"required,nullable" format:"uuid"`
	SchemaName           string                                                                   `json:"schemaName" api:"required"`
	TableName            string                                                                   `json:"tableName" api:"required"`
	JSON                 inferencePipelineUpdateResponseDataBackendRedshiftDataBackendJSON        `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendRedshiftDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendRedshiftDataBackendBackendType added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendRedshiftDataBackendBackendType string
const (
	InferencePipelineUpdateResponseDataBackendRedshiftDataBackendBackendTypeRedshift InferencePipelineUpdateResponseDataBackendRedshiftDataBackendBackendType = "redshift"
)

func (InferencePipelineUpdateResponseDataBackendRedshiftDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendRedshiftDataBackendBackendType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendRedshiftDataBackendConfig added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendRedshiftDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                  `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineUpdateResponseDataBackendRedshiftDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendRedshiftDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendSnowflakeDataBackend added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendSnowflakeDataBackend struct {
	BackendType           InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendBackendType `json:"backendType" api:"required"`
	Database              string                                                                    `json:"database" api:"required"`
	Schema                string                                                                    `json:"schema" api:"required"`
	SnowflakeConnectionID string                                                                    `json:"snowflakeConnectionId" api:"required,nullable" format:"uuid"`
	Table                 string                                                                    `json:"table" api:"required,nullable"`
	JSON                  inferencePipelineUpdateResponseDataBackendSnowflakeDataBackendJSON        `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendSnowflakeDataBackend) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendBackendType added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendBackendType string
const (
	InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendBackendTypeSnowflake InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendBackendType = "snowflake"
)

func (InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendBackendType) IsKnown added in v0.3.1 

func (r InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendBackendType) IsKnown() bool

type InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendConfig added in v0.3.1 

type InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                   `json:"timestampColumnName" api:"nullable"`
	JSON                inferencePipelineUpdateResponseDataBackendSnowflakeDataBackendConfigJSON `json:"-"`
}

func (*InferencePipelineUpdateResponseDataBackendSnowflakeDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type InferencePipelineUpdateResponseDataBackendUnion added in v0.2.0 

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

Union satisfied by InferencePipelineUpdateResponseDataBackendBigQueryDataBackend, InferencePipelineUpdateResponseDataBackendDefaultDataBackend, InferencePipelineUpdateResponseDataBackendSnowflakeDataBackend, InferencePipelineUpdateResponseDataBackendDatabricksDtlDataBackend, InferencePipelineUpdateResponseDataBackendRedshiftDataBackend or InferencePipelineUpdateResponseDataBackendPostgresDataBackend. 

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

func (*InferencePipelineUpdateResponseProject) UnmarshalJSON 

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

type InferencePipelineUpdateResponseProjectGitRepo 

type InferencePipelineUpdateResponseProjectGitRepo struct {
	ID            string                                            `json:"id" api:"required" format:"uuid"`
	DateConnected time.Time                                         `json:"dateConnected" api:"required" format:"date-time"`
	DateUpdated   time.Time                                         `json:"dateUpdated" api:"required" format:"date-time"`
	GitAccountID  string                                            `json:"gitAccountId" api:"required" format:"uuid"`
	GitID         int64                                             `json:"gitId" api:"required"`
	Name          string                                            `json:"name" api:"required"`
	Private       bool                                              `json:"private" api:"required"`
	ProjectID     string                                            `json:"projectId" api:"required" format:"uuid"`
	Slug          string                                            `json:"slug" api:"required"`
	URL           string                                            `json:"url" api:"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" api:"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" api:"required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount" api:"required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount" api:"required"`
	// The workspace name.
	Name string `json:"name" api:"required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate" api:"required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate" api:"required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount" api:"required"`
	// The workspace slug.
	Slug         string                                                 `json:"slug" api:"required"`
	Status       InferencePipelineUpdateResponseWorkspaceStatus         `json:"status" api:"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" api:"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" api:"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" api:"required" format:"uuid"`
	// The details of a commit (project version).
	Commit ProjectCommitListResponseItemsCommit `json:"commit" api:"required"`
	// The commit archive date.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The project version (commit) creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The number of tests that are failing for the commit.
	FailingGoalCount int64 `json:"failingGoalCount" api:"required"`
	// The model id.
	MlModelID string `json:"mlModelId" api:"required,nullable" format:"uuid"`
	// The number of tests that are passing for the commit.
	PassingGoalCount int64 `json:"passingGoalCount" api:"required"`
	// The project id.
	ProjectID string `json:"projectId" api:"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" api:"required"`
	// The commit status message.
	StatusMessage string `json:"statusMessage" api:"required,nullable"`
	// The total number of tests for the commit.
	TotalGoalCount int64 `json:"totalGoalCount" api:"required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId" api:"required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId" api:"required,nullable" format:"uuid"`
	// Whether the commit is archived.
	Archived bool `json:"archived" api:"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" api:"required" format:"uuid"`
	// The author id of the commit.
	AuthorID string `json:"authorId" api:"required" format:"uuid"`
	// The size of the commit bundle in bytes.
	FileSize int64 `json:"fileSize" api:"required,nullable"`
	// The commit message.
	Message string `json:"message" api:"required"`
	// The model id.
	MlModelID string `json:"mlModelId" api:"required,nullable" format:"uuid"`
	// The storage URI where the commit bundle is stored.
	StorageUri string `json:"storageUri" api:"required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId" api:"required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId" api:"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" api:"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" api:"required"`
	// The storage URI where the commit bundle is stored.
	StorageUri param.Field[string] `json:"storageUri" api:"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" api:"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" api:"required" format:"uuid"`
	// The details of a commit (project version).
	Commit ProjectCommitNewResponseCommit `json:"commit" api:"required"`
	// The commit archive date.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The project version (commit) creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The number of tests that are failing for the commit.
	FailingGoalCount int64 `json:"failingGoalCount" api:"required"`
	// The model id.
	MlModelID string `json:"mlModelId" api:"required,nullable" format:"uuid"`
	// The number of tests that are passing for the commit.
	PassingGoalCount int64 `json:"passingGoalCount" api:"required"`
	// The project id.
	ProjectID string `json:"projectId" api:"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" api:"required"`
	// The commit status message.
	StatusMessage string `json:"statusMessage" api:"required,nullable"`
	// The total number of tests for the commit.
	TotalGoalCount int64 `json:"totalGoalCount" api:"required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId" api:"required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId" api:"required,nullable" format:"uuid"`
	// Whether the commit is archived.
	Archived bool `json:"archived" api:"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" api:"required" format:"uuid"`
	// The author id of the commit.
	AuthorID string `json:"authorId" api:"required" format:"uuid"`
	// The size of the commit bundle in bytes.
	FileSize int64 `json:"fileSize" api:"required,nullable"`
	// The commit message.
	Message string `json:"message" api:"required"`
	// The model id.
	MlModelID string `json:"mlModelId" api:"required,nullable" format:"uuid"`
	// The storage URI where the commit bundle is stored.
	StorageUri string `json:"storageUri" api:"required"`
	// The training dataset id.
	TrainingDatasetID string `json:"trainingDatasetId" api:"required,nullable" format:"uuid"`
	// The validation dataset id.
	ValidationDatasetID string `json:"validationDatasetId" api:"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" api:"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" api:"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" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated" api:"required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived" api:"required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description" api:"required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                                          `json:"failingGoalCount" api:"required"`
	Links            ProjectInferencePipelineListResponseItemsLinks `json:"links" api:"required"`
	// The inference pipeline name.
	Name string `json:"name" api:"required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount" api:"required"`
	// The project id.
	ProjectID string `json:"projectId" api:"required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status ProjectInferencePipelineListResponseItemsStatus `json:"status" api:"required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage" api:"required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                                `json:"totalGoalCount" api:"required"`
	DataBackend    ProjectInferencePipelineListResponseItemsDataBackend `json:"dataBackend" api:"nullable"`
	// The last time the data was polled.
	DateLastPolled time.Time                                        `json:"dateLastPolled" api:"nullable" format:"date-time"`
	Project        ProjectInferencePipelineListResponseItemsProject `json:"project" api:"nullable"`
	// The total number of records in the data backend.
	TotalRecordsCount int64                                              `json:"totalRecordsCount" api:"nullable"`
	Workspace         ProjectInferencePipelineListResponseItemsWorkspace `json:"workspace" api:"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 ProjectInferencePipelineListResponseItemsDataBackend added in v0.2.0 

type ProjectInferencePipelineListResponseItemsDataBackend struct {
	BackendType          ProjectInferencePipelineListResponseItemsDataBackendBackendType `json:"backendType" api:"required"`
	BigqueryConnectionID string                                                          `json:"bigqueryConnectionId" api:"nullable" format:"uuid"`
	// This field can have the runtime type of
	// [ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendConfig],
	// [ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendConfig],
	// [ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendConfig],
	// [ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendConfig],
	// [ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendConfig].
	Config                    interface{}                                                       `json:"config"`
	Database                  string                                                            `json:"database"`
	DatabricksDtlConnectionID string                                                            `json:"databricksDtlConnectionId" api:"nullable" format:"uuid"`
	DatasetID                 string                                                            `json:"datasetId"`
	PartitionType             ProjectInferencePipelineListResponseItemsDataBackendPartitionType `json:"partitionType" api:"nullable"`
	PostgresConnectionID      string                                                            `json:"postgresConnectionId" api:"nullable" format:"uuid"`
	ProjectID                 string                                                            `json:"projectId"`
	RedshiftConnectionID      string                                                            `json:"redshiftConnectionId" api:"nullable" format:"uuid"`
	Schema                    string                                                            `json:"schema"`
	SchemaName                string                                                            `json:"schemaName"`
	SnowflakeConnectionID     string                                                            `json:"snowflakeConnectionId" api:"nullable" format:"uuid"`
	Table                     string                                                            `json:"table" api:"nullable"`
	TableID                   string                                                            `json:"tableId" api:"nullable"`
	TableName                 string                                                            `json:"tableName"`
	JSON                      projectInferencePipelineListResponseItemsDataBackendJSON          `json:"-"`
	// contains filtered or unexported fields
}

func (ProjectInferencePipelineListResponseItemsDataBackend) AsUnion added in v0.2.0 

func (r ProjectInferencePipelineListResponseItemsDataBackend) AsUnion() ProjectInferencePipelineListResponseItemsDataBackendUnion

AsUnion returns a ProjectInferencePipelineListResponseItemsDataBackendUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackend, ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackend, ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackend, ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackend, ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackend, ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackend.

func (*ProjectInferencePipelineListResponseItemsDataBackend) UnmarshalJSON added in v0.2.0 

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

type ProjectInferencePipelineListResponseItemsDataBackendBackendType added in v0.2.0 

type ProjectInferencePipelineListResponseItemsDataBackendBackendType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendBackendTypeBigquery      ProjectInferencePipelineListResponseItemsDataBackendBackendType = "bigquery"
	ProjectInferencePipelineListResponseItemsDataBackendBackendTypeDefault       ProjectInferencePipelineListResponseItemsDataBackendBackendType = "default"
	ProjectInferencePipelineListResponseItemsDataBackendBackendTypeSnowflake     ProjectInferencePipelineListResponseItemsDataBackendBackendType = "snowflake"
	ProjectInferencePipelineListResponseItemsDataBackendBackendTypeDatabricksDtl ProjectInferencePipelineListResponseItemsDataBackendBackendType = "databricks_dtl"
	ProjectInferencePipelineListResponseItemsDataBackendBackendTypeRedshift      ProjectInferencePipelineListResponseItemsDataBackendBackendType = "redshift"
	ProjectInferencePipelineListResponseItemsDataBackendBackendTypePostgres      ProjectInferencePipelineListResponseItemsDataBackendBackendType = "postgres"
)

func (ProjectInferencePipelineListResponseItemsDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackend added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackend struct {
	BackendType          ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendBackendType   `json:"backendType" api:"required"`
	BigqueryConnectionID string                                                                               `json:"bigqueryConnectionId" api:"required,nullable" format:"uuid"`
	DatasetID            string                                                                               `json:"datasetId" api:"required"`
	ProjectID            string                                                                               `json:"projectId" api:"required"`
	TableID              string                                                                               `json:"tableId" api:"required,nullable"`
	PartitionType        ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType `json:"partitionType" api:"nullable"`
	JSON                 projectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendJSON          `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendBackendType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendBackendTypeBigquery ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendBackendType = "bigquery"
)

func (ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                            `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionTypeDay   ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType = "DAY"
	ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionTypeMonth ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType = "MONTH"
	ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionTypeYear  ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType = "YEAR"
)

func (ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackendPartitionType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackend added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackend struct {
	BackendType               ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendBackendType `json:"backendType" api:"required"`
	DatabricksDtlConnectionID string                                                                                  `json:"databricksDtlConnectionId" api:"required,nullable" format:"uuid"`
	TableID                   string                                                                                  `json:"tableId" api:"required,nullable"`
	JSON                      projectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendBackendType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendBackendTypeDatabricksDtl ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendBackendType = "databricks_dtl"
)

func (ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                                 `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackend added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackend struct {
	BackendType ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackendBackendType `json:"backendType" api:"required"`
	JSON        projectInferencePipelineListResponseItemsDataBackendDefaultDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackendBackendType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackendBackendTypeDefault ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackendBackendType = "default"
)

func (ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendPartitionType added in v0.2.0 

type ProjectInferencePipelineListResponseItemsDataBackendPartitionType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendPartitionTypeDay   ProjectInferencePipelineListResponseItemsDataBackendPartitionType = "DAY"
	ProjectInferencePipelineListResponseItemsDataBackendPartitionTypeMonth ProjectInferencePipelineListResponseItemsDataBackendPartitionType = "MONTH"
	ProjectInferencePipelineListResponseItemsDataBackendPartitionTypeYear  ProjectInferencePipelineListResponseItemsDataBackendPartitionType = "YEAR"
)

func (ProjectInferencePipelineListResponseItemsDataBackendPartitionType) IsKnown added in v0.2.0 

func (r ProjectInferencePipelineListResponseItemsDataBackendPartitionType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackend added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackend struct {
	BackendType          ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendBackendType `json:"backendType" api:"required"`
	Database             string                                                                             `json:"database" api:"required"`
	PostgresConnectionID string                                                                             `json:"postgresConnectionId" api:"required,nullable" format:"uuid"`
	Schema               string                                                                             `json:"schema" api:"required"`
	Table                string                                                                             `json:"table" api:"required,nullable"`
	JSON                 projectInferencePipelineListResponseItemsDataBackendPostgresDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendBackendType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendBackendTypePostgres ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendBackendType = "postgres"
)

func (ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                            `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineListResponseItemsDataBackendPostgresDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackend added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackend struct {
	BackendType          ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendBackendType `json:"backendType" api:"required"`
	RedshiftConnectionID string                                                                             `json:"redshiftConnectionId" api:"required,nullable" format:"uuid"`
	SchemaName           string                                                                             `json:"schemaName" api:"required"`
	TableName            string                                                                             `json:"tableName" api:"required"`
	JSON                 projectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendBackendType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendBackendTypeRedshift ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendBackendType = "redshift"
)

func (ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                            `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackend added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackend struct {
	BackendType           ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendBackendType `json:"backendType" api:"required"`
	Database              string                                                                              `json:"database" api:"required"`
	Schema                string                                                                              `json:"schema" api:"required"`
	SnowflakeConnectionID string                                                                              `json:"snowflakeConnectionId" api:"required,nullable" format:"uuid"`
	Table                 string                                                                              `json:"table" api:"required,nullable"`
	JSON                  projectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendBackendType string
const (
	ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendBackendTypeSnowflake ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendBackendType = "snowflake"
)

func (ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                             `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineListResponseItemsDataBackendUnion added in v0.2.0 

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

Union satisfied by ProjectInferencePipelineListResponseItemsDataBackendBigQueryDataBackend, ProjectInferencePipelineListResponseItemsDataBackendDefaultDataBackend, ProjectInferencePipelineListResponseItemsDataBackendSnowflakeDataBackend, ProjectInferencePipelineListResponseItemsDataBackendDatabricksDtlDataBackend, ProjectInferencePipelineListResponseItemsDataBackendRedshiftDataBackend or ProjectInferencePipelineListResponseItemsDataBackendPostgresDataBackend. 

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

func (*ProjectInferencePipelineListResponseItemsProject) UnmarshalJSON 

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

type ProjectInferencePipelineListResponseItemsProjectGitRepo 

type ProjectInferencePipelineListResponseItemsProjectGitRepo struct {
	ID            string                                                      `json:"id" api:"required" format:"uuid"`
	DateConnected time.Time                                                   `json:"dateConnected" api:"required" format:"date-time"`
	DateUpdated   time.Time                                                   `json:"dateUpdated" api:"required" format:"date-time"`
	GitAccountID  string                                                      `json:"gitAccountId" api:"required" format:"uuid"`
	GitID         int64                                                       `json:"gitId" api:"required"`
	Name          string                                                      `json:"name" api:"required"`
	Private       bool                                                        `json:"private" api:"required"`
	ProjectID     string                                                      `json:"projectId" api:"required" format:"uuid"`
	Slug          string                                                      `json:"slug" api:"required"`
	URL           string                                                      `json:"url" api:"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" api:"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" api:"required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount" api:"required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount" api:"required"`
	// The workspace name.
	Name string `json:"name" api:"required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate" api:"required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate" api:"required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount" api:"required"`
	// The workspace slug.
	Slug         string                                                           `json:"slug" api:"required"`
	Status       ProjectInferencePipelineListResponseItemsWorkspaceStatus         `json:"status" api:"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" api:"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" api:"required"`
	// The inference pipeline name.
	Name        param.Field[string]                                            `json:"name" api:"required"`
	DataBackend param.Field[ProjectInferencePipelineNewParamsDataBackendUnion] `json:"dataBackend"`
	Project     param.Field[ProjectInferencePipelineNewParamsProject]          `json:"project"`
	Workspace   param.Field[ProjectInferencePipelineNewParamsWorkspace]        `json:"workspace"`
}

func (ProjectInferencePipelineNewParams) MarshalJSON 

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

type ProjectInferencePipelineNewParamsDataBackend added in v0.2.0 

type ProjectInferencePipelineNewParamsDataBackend struct {
	BackendType               param.Field[ProjectInferencePipelineNewParamsDataBackendBackendType]   `json:"backendType" api:"required"`
	BigqueryConnectionID      param.Field[string]                                                    `json:"bigqueryConnectionId" format:"uuid"`
	Config                    param.Field[interface{}]                                               `json:"config"`
	Database                  param.Field[string]                                                    `json:"database"`
	DatabricksDtlConnectionID param.Field[string]                                                    `json:"databricksDtlConnectionId" format:"uuid"`
	DatasetID                 param.Field[string]                                                    `json:"datasetId"`
	PartitionType             param.Field[ProjectInferencePipelineNewParamsDataBackendPartitionType] `json:"partitionType"`
	PostgresConnectionID      param.Field[string]                                                    `json:"postgresConnectionId" format:"uuid"`
	ProjectID                 param.Field[string]                                                    `json:"projectId"`
	RedshiftConnectionID      param.Field[string]                                                    `json:"redshiftConnectionId" format:"uuid"`
	Schema                    param.Field[string]                                                    `json:"schema"`
	SchemaName                param.Field[string]                                                    `json:"schemaName"`
	SnowflakeConnectionID     param.Field[string]                                                    `json:"snowflakeConnectionId" format:"uuid"`
	Table                     param.Field[string]                                                    `json:"table"`
	TableID                   param.Field[string]                                                    `json:"tableId"`
	TableName                 param.Field[string]                                                    `json:"tableName"`
}

func (ProjectInferencePipelineNewParamsDataBackend) MarshalJSON added in v0.2.0 

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

type ProjectInferencePipelineNewParamsDataBackendBackendType added in v0.2.0 

type ProjectInferencePipelineNewParamsDataBackendBackendType string
const (
	ProjectInferencePipelineNewParamsDataBackendBackendTypeBigquery      ProjectInferencePipelineNewParamsDataBackendBackendType = "bigquery"
	ProjectInferencePipelineNewParamsDataBackendBackendTypeDefault       ProjectInferencePipelineNewParamsDataBackendBackendType = "default"
	ProjectInferencePipelineNewParamsDataBackendBackendTypeSnowflake     ProjectInferencePipelineNewParamsDataBackendBackendType = "snowflake"
	ProjectInferencePipelineNewParamsDataBackendBackendTypeDatabricksDtl ProjectInferencePipelineNewParamsDataBackendBackendType = "databricks_dtl"
	ProjectInferencePipelineNewParamsDataBackendBackendTypeRedshift      ProjectInferencePipelineNewParamsDataBackendBackendType = "redshift"
	ProjectInferencePipelineNewParamsDataBackendBackendTypePostgres      ProjectInferencePipelineNewParamsDataBackendBackendType = "postgres"
)

func (ProjectInferencePipelineNewParamsDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackend added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackend struct {
	BackendType          param.Field[ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendBackendType]   `json:"backendType" api:"required"`
	BigqueryConnectionID param.Field[string]                                                                       `json:"bigqueryConnectionId" api:"required" format:"uuid"`
	Config               param.Field[ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendConfig]        `json:"config" api:"required"`
	DatasetID            param.Field[string]                                                                       `json:"datasetId" api:"required"`
	ProjectID            param.Field[string]                                                                       `json:"projectId" api:"required"`
	TableID              param.Field[string]                                                                       `json:"tableId" api:"required"`
	PartitionType        param.Field[ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType] `json:"partitionType"`
}

func (ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackend) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendBackendType string
const (
	ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendBackendTypeBigquery ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendBackendType = "bigquery"
)

func (ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendConfig 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 (ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendConfig) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType string
const (
	ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionTypeDay   ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType = "DAY"
	ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionTypeMonth ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType = "MONTH"
	ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionTypeYear  ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType = "YEAR"
)

func (ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackendPartitionType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackend added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackend struct {
	BackendType               param.Field[ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendBackendType] `json:"backendType" api:"required"`
	Config                    param.Field[ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendConfig]      `json:"config" api:"required"`
	DatabricksDtlConnectionID param.Field[string]                                                                          `json:"databricksDtlConnectionId" api:"required" format:"uuid"`
	TableID                   param.Field[string]                                                                          `json:"tableId" api:"required"`
}

func (ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackend) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendBackendType string
const (
	ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendBackendTypeDatabricksDtl ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendBackendType = "databricks_dtl"
)

func (ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendConfig 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 (ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackendConfig) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendDefaultDataBackend added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendDefaultDataBackend struct {
	BackendType param.Field[ProjectInferencePipelineNewParamsDataBackendDefaultDataBackendBackendType] `json:"backendType" api:"required"`
}

func (ProjectInferencePipelineNewParamsDataBackendDefaultDataBackend) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendDefaultDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendDefaultDataBackendBackendType string
const (
	ProjectInferencePipelineNewParamsDataBackendDefaultDataBackendBackendTypeDefault ProjectInferencePipelineNewParamsDataBackendDefaultDataBackendBackendType = "default"
)

func (ProjectInferencePipelineNewParamsDataBackendDefaultDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendDefaultDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendPartitionType added in v0.2.0 

type ProjectInferencePipelineNewParamsDataBackendPartitionType string
const (
	ProjectInferencePipelineNewParamsDataBackendPartitionTypeDay   ProjectInferencePipelineNewParamsDataBackendPartitionType = "DAY"
	ProjectInferencePipelineNewParamsDataBackendPartitionTypeMonth ProjectInferencePipelineNewParamsDataBackendPartitionType = "MONTH"
	ProjectInferencePipelineNewParamsDataBackendPartitionTypeYear  ProjectInferencePipelineNewParamsDataBackendPartitionType = "YEAR"
)

func (ProjectInferencePipelineNewParamsDataBackendPartitionType) IsKnown added in v0.2.0 

func (r ProjectInferencePipelineNewParamsDataBackendPartitionType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendPostgresDataBackend added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendPostgresDataBackend struct {
	BackendType          param.Field[ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendBackendType] `json:"backendType" api:"required"`
	Config               param.Field[ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendConfig]      `json:"config" api:"required"`
	Database             param.Field[string]                                                                     `json:"database" api:"required"`
	PostgresConnectionID param.Field[string]                                                                     `json:"postgresConnectionId" api:"required" format:"uuid"`
	Schema               param.Field[string]                                                                     `json:"schema" api:"required"`
	Table                param.Field[string]                                                                     `json:"table" api:"required"`
}

func (ProjectInferencePipelineNewParamsDataBackendPostgresDataBackend) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendBackendType string
const (
	ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendBackendTypePostgres ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendBackendType = "postgres"
)

func (ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendConfig 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 (ProjectInferencePipelineNewParamsDataBackendPostgresDataBackendConfig) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackend added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackend struct {
	BackendType          param.Field[ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendBackendType] `json:"backendType" api:"required"`
	Config               param.Field[ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendConfig]      `json:"config" api:"required"`
	RedshiftConnectionID param.Field[string]                                                                     `json:"redshiftConnectionId" api:"required" format:"uuid"`
	SchemaName           param.Field[string]                                                                     `json:"schemaName" api:"required"`
	TableName            param.Field[string]                                                                     `json:"tableName" api:"required"`
}

func (ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackend) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendBackendType string
const (
	ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendBackendTypeRedshift ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendBackendType = "redshift"
)

func (ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendConfig 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 (ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackendConfig) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackend added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackend struct {
	BackendType           param.Field[ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendBackendType] `json:"backendType" api:"required"`
	Config                param.Field[ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendConfig]      `json:"config" api:"required"`
	Database              param.Field[string]                                                                      `json:"database" api:"required"`
	Schema                param.Field[string]                                                                      `json:"schema" api:"required"`
	SnowflakeConnectionID param.Field[string]                                                                      `json:"snowflakeConnectionId" api:"required" format:"uuid"`
	Table                 param.Field[string]                                                                      `json:"table" api:"required"`
}

func (ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackend) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendBackendType string
const (
	ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendBackendTypeSnowflake ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendBackendType = "snowflake"
)

func (ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendConfig 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 (ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackendConfig) MarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewParamsDataBackendUnion added in v0.2.0 

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

Satisfied by ProjectInferencePipelineNewParamsDataBackendBigQueryDataBackend, ProjectInferencePipelineNewParamsDataBackendDefaultDataBackend, ProjectInferencePipelineNewParamsDataBackendSnowflakeDataBackend, ProjectInferencePipelineNewParamsDataBackendDatabricksDtlDataBackend, ProjectInferencePipelineNewParamsDataBackendRedshiftDataBackend, ProjectInferencePipelineNewParamsDataBackendPostgresDataBackend, ProjectInferencePipelineNewParamsDataBackend.

type ProjectInferencePipelineNewParamsProject 

type ProjectInferencePipelineNewParamsProject struct {
	// The project name.
	Name param.Field[string] `json:"name" api:"required"`
	// The task type of the project.
	TaskType param.Field[ProjectInferencePipelineNewParamsProjectTaskType] `json:"taskType" api:"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" api:"required" format:"uuid"`
	GitID        param.Field[int64]  `json:"gitId" api:"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" api:"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" api:"required"`
	// The workspace slug.
	Slug param.Field[string] `json:"slug" api:"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" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last test evaluation date.
	DateLastEvaluated time.Time `json:"dateLastEvaluated" api:"required,nullable" format:"date-time"`
	// The last data sample received date.
	DateLastSampleReceived time.Time `json:"dateLastSampleReceived" api:"required,nullable" format:"date-time"`
	// The next test evaluation date.
	DateOfNextEvaluation time.Time `json:"dateOfNextEvaluation" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline description.
	Description string `json:"description" api:"required,nullable"`
	// The number of tests failing.
	FailingGoalCount int64                                    `json:"failingGoalCount" api:"required"`
	Links            ProjectInferencePipelineNewResponseLinks `json:"links" api:"required"`
	// The inference pipeline name.
	Name string `json:"name" api:"required"`
	// The number of tests passing.
	PassingGoalCount int64 `json:"passingGoalCount" api:"required"`
	// The project id.
	ProjectID string `json:"projectId" api:"required" format:"uuid"`
	// The status of test evaluation for the inference pipeline.
	Status ProjectInferencePipelineNewResponseStatus `json:"status" api:"required"`
	// The status message of test evaluation for the inference pipeline.
	StatusMessage string `json:"statusMessage" api:"required,nullable"`
	// The total number of tests.
	TotalGoalCount int64                                          `json:"totalGoalCount" api:"required"`
	DataBackend    ProjectInferencePipelineNewResponseDataBackend `json:"dataBackend" api:"nullable"`
	// The last time the data was polled.
	DateLastPolled time.Time                                  `json:"dateLastPolled" api:"nullable" format:"date-time"`
	Project        ProjectInferencePipelineNewResponseProject `json:"project" api:"nullable"`
	// The total number of records in the data backend.
	TotalRecordsCount int64                                        `json:"totalRecordsCount" api:"nullable"`
	Workspace         ProjectInferencePipelineNewResponseWorkspace `json:"workspace" api:"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 ProjectInferencePipelineNewResponseDataBackend added in v0.2.0 

type ProjectInferencePipelineNewResponseDataBackend struct {
	BackendType          ProjectInferencePipelineNewResponseDataBackendBackendType `json:"backendType" api:"required"`
	BigqueryConnectionID string                                                    `json:"bigqueryConnectionId" api:"nullable" format:"uuid"`
	// This field can have the runtime type of
	// [ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendConfig],
	// [ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendConfig],
	// [ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendConfig],
	// [ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendConfig],
	// [ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendConfig].
	Config                    interface{}                                                 `json:"config"`
	Database                  string                                                      `json:"database"`
	DatabricksDtlConnectionID string                                                      `json:"databricksDtlConnectionId" api:"nullable" format:"uuid"`
	DatasetID                 string                                                      `json:"datasetId"`
	PartitionType             ProjectInferencePipelineNewResponseDataBackendPartitionType `json:"partitionType" api:"nullable"`
	PostgresConnectionID      string                                                      `json:"postgresConnectionId" api:"nullable" format:"uuid"`
	ProjectID                 string                                                      `json:"projectId"`
	RedshiftConnectionID      string                                                      `json:"redshiftConnectionId" api:"nullable" format:"uuid"`
	Schema                    string                                                      `json:"schema"`
	SchemaName                string                                                      `json:"schemaName"`
	SnowflakeConnectionID     string                                                      `json:"snowflakeConnectionId" api:"nullable" format:"uuid"`
	Table                     string                                                      `json:"table" api:"nullable"`
	TableID                   string                                                      `json:"tableId" api:"nullable"`
	TableName                 string                                                      `json:"tableName"`
	JSON                      projectInferencePipelineNewResponseDataBackendJSON          `json:"-"`
	// contains filtered or unexported fields
}

func (ProjectInferencePipelineNewResponseDataBackend) AsUnion added in v0.2.0 

func (r ProjectInferencePipelineNewResponseDataBackend) AsUnion() ProjectInferencePipelineNewResponseDataBackendUnion

AsUnion returns a ProjectInferencePipelineNewResponseDataBackendUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackend, ProjectInferencePipelineNewResponseDataBackendDefaultDataBackend, ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackend, ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackend, ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackend, ProjectInferencePipelineNewResponseDataBackendPostgresDataBackend.

func (*ProjectInferencePipelineNewResponseDataBackend) UnmarshalJSON added in v0.2.0 

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

type ProjectInferencePipelineNewResponseDataBackendBackendType added in v0.2.0 

type ProjectInferencePipelineNewResponseDataBackendBackendType string
const (
	ProjectInferencePipelineNewResponseDataBackendBackendTypeBigquery      ProjectInferencePipelineNewResponseDataBackendBackendType = "bigquery"
	ProjectInferencePipelineNewResponseDataBackendBackendTypeDefault       ProjectInferencePipelineNewResponseDataBackendBackendType = "default"
	ProjectInferencePipelineNewResponseDataBackendBackendTypeSnowflake     ProjectInferencePipelineNewResponseDataBackendBackendType = "snowflake"
	ProjectInferencePipelineNewResponseDataBackendBackendTypeDatabricksDtl ProjectInferencePipelineNewResponseDataBackendBackendType = "databricks_dtl"
	ProjectInferencePipelineNewResponseDataBackendBackendTypeRedshift      ProjectInferencePipelineNewResponseDataBackendBackendType = "redshift"
	ProjectInferencePipelineNewResponseDataBackendBackendTypePostgres      ProjectInferencePipelineNewResponseDataBackendBackendType = "postgres"
)

func (ProjectInferencePipelineNewResponseDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackend added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackend struct {
	BackendType          ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendBackendType   `json:"backendType" api:"required"`
	BigqueryConnectionID string                                                                         `json:"bigqueryConnectionId" api:"required,nullable" format:"uuid"`
	DatasetID            string                                                                         `json:"datasetId" api:"required"`
	ProjectID            string                                                                         `json:"projectId" api:"required"`
	TableID              string                                                                         `json:"tableId" api:"required,nullable"`
	PartitionType        ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType `json:"partitionType" api:"nullable"`
	JSON                 projectInferencePipelineNewResponseDataBackendBigQueryDataBackendJSON          `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendBackendType string
const (
	ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendBackendTypeBigquery ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendBackendType = "bigquery"
)

func (ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                      `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineNewResponseDataBackendBigQueryDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType string
const (
	ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionTypeDay   ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType = "DAY"
	ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionTypeMonth ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType = "MONTH"
	ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionTypeYear  ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType = "YEAR"
)

func (ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackendPartitionType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackend added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackend struct {
	BackendType               ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendBackendType `json:"backendType" api:"required"`
	DatabricksDtlConnectionID string                                                                            `json:"databricksDtlConnectionId" api:"required,nullable" format:"uuid"`
	TableID                   string                                                                            `json:"tableId" api:"required,nullable"`
	JSON                      projectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendBackendType string
const (
	ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendBackendTypeDatabricksDtl ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendBackendType = "databricks_dtl"
)

func (ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                           `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendDefaultDataBackend added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendDefaultDataBackend struct {
	BackendType ProjectInferencePipelineNewResponseDataBackendDefaultDataBackendBackendType `json:"backendType" api:"required"`
	JSON        projectInferencePipelineNewResponseDataBackendDefaultDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendDefaultDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendDefaultDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendDefaultDataBackendBackendType string
const (
	ProjectInferencePipelineNewResponseDataBackendDefaultDataBackendBackendTypeDefault ProjectInferencePipelineNewResponseDataBackendDefaultDataBackendBackendType = "default"
)

func (ProjectInferencePipelineNewResponseDataBackendDefaultDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendDefaultDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendPartitionType added in v0.2.0 

type ProjectInferencePipelineNewResponseDataBackendPartitionType string
const (
	ProjectInferencePipelineNewResponseDataBackendPartitionTypeDay   ProjectInferencePipelineNewResponseDataBackendPartitionType = "DAY"
	ProjectInferencePipelineNewResponseDataBackendPartitionTypeMonth ProjectInferencePipelineNewResponseDataBackendPartitionType = "MONTH"
	ProjectInferencePipelineNewResponseDataBackendPartitionTypeYear  ProjectInferencePipelineNewResponseDataBackendPartitionType = "YEAR"
)

func (ProjectInferencePipelineNewResponseDataBackendPartitionType) IsKnown added in v0.2.0 

func (r ProjectInferencePipelineNewResponseDataBackendPartitionType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendPostgresDataBackend added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendPostgresDataBackend struct {
	BackendType          ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendBackendType `json:"backendType" api:"required"`
	Database             string                                                                       `json:"database" api:"required"`
	PostgresConnectionID string                                                                       `json:"postgresConnectionId" api:"required,nullable" format:"uuid"`
	Schema               string                                                                       `json:"schema" api:"required"`
	Table                string                                                                       `json:"table" api:"required,nullable"`
	JSON                 projectInferencePipelineNewResponseDataBackendPostgresDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendPostgresDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendBackendType string
const (
	ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendBackendTypePostgres ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendBackendType = "postgres"
)

func (ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                      `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineNewResponseDataBackendPostgresDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendPostgresDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackend added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackend struct {
	BackendType          ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendBackendType `json:"backendType" api:"required"`
	RedshiftConnectionID string                                                                       `json:"redshiftConnectionId" api:"required,nullable" format:"uuid"`
	SchemaName           string                                                                       `json:"schemaName" api:"required"`
	TableName            string                                                                       `json:"tableName" api:"required"`
	JSON                 projectInferencePipelineNewResponseDataBackendRedshiftDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendBackendType string
const (
	ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendBackendTypeRedshift ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendBackendType = "redshift"
)

func (ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                      `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineNewResponseDataBackendRedshiftDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackend added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackend struct {
	BackendType           ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendBackendType `json:"backendType" api:"required"`
	Database              string                                                                        `json:"database" api:"required"`
	Schema                string                                                                        `json:"schema" api:"required"`
	SnowflakeConnectionID string                                                                        `json:"snowflakeConnectionId" api:"required,nullable" format:"uuid"`
	Table                 string                                                                        `json:"table" api:"required,nullable"`
	JSON                  projectInferencePipelineNewResponseDataBackendSnowflakeDataBackendJSON        `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackend) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendBackendType added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendBackendType string
const (
	ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendBackendTypeSnowflake ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendBackendType = "snowflake"
)

func (ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendBackendType) IsKnown added in v0.3.1 

func (r ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendBackendType) IsKnown() bool

type ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendConfig added in v0.3.1 

type ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendConfig struct {
	// Name of the column with the ground truths.
	GroundTruthColumnName string `json:"groundTruthColumnName" api:"nullable"`
	// Name of the column with human feedback.
	HumanFeedbackColumnName string `json:"humanFeedbackColumnName" api:"nullable"`
	// Name of the column with the latencies.
	LatencyColumnName string `json:"latencyColumnName" api:"nullable"`
	// Name of the column with the timestamps. Timestamps must be in UNIX sec format.
	// If not provided, the upload timestamp is used.
	TimestampColumnName string                                                                       `json:"timestampColumnName" api:"nullable"`
	JSON                projectInferencePipelineNewResponseDataBackendSnowflakeDataBackendConfigJSON `json:"-"`
}

func (*ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackendConfig) UnmarshalJSON added in v0.3.1 

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

type ProjectInferencePipelineNewResponseDataBackendUnion added in v0.2.0 

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

Union satisfied by ProjectInferencePipelineNewResponseDataBackendBigQueryDataBackend, ProjectInferencePipelineNewResponseDataBackendDefaultDataBackend, ProjectInferencePipelineNewResponseDataBackendSnowflakeDataBackend, ProjectInferencePipelineNewResponseDataBackendDatabricksDtlDataBackend, ProjectInferencePipelineNewResponseDataBackendRedshiftDataBackend or ProjectInferencePipelineNewResponseDataBackendPostgresDataBackend. 

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

func (*ProjectInferencePipelineNewResponseProject) UnmarshalJSON 

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

type ProjectInferencePipelineNewResponseProjectGitRepo 

type ProjectInferencePipelineNewResponseProjectGitRepo struct {
	ID            string                                                `json:"id" api:"required" format:"uuid"`
	DateConnected time.Time                                             `json:"dateConnected" api:"required" format:"date-time"`
	DateUpdated   time.Time                                             `json:"dateUpdated" api:"required" format:"date-time"`
	GitAccountID  string                                                `json:"gitAccountId" api:"required" format:"uuid"`
	GitID         int64                                                 `json:"gitId" api:"required"`
	Name          string                                                `json:"name" api:"required"`
	Private       bool                                                  `json:"private" api:"required"`
	ProjectID     string                                                `json:"projectId" api:"required" format:"uuid"`
	Slug          string                                                `json:"slug" api:"required"`
	URL           string                                                `json:"url" api:"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" api:"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" api:"required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount" api:"required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount" api:"required"`
	// The workspace name.
	Name string `json:"name" api:"required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate" api:"required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate" api:"required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount" api:"required"`
	// The workspace slug.
	Slug         string                                                     `json:"slug" api:"required"`
	Status       ProjectInferencePipelineNewResponseWorkspaceStatus         `json:"status" api:"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" api:"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" api:"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" api:"required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount" api:"required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount" api:"required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount" api:"required"`
	// Links to the project.
	Links ProjectListResponseItemsLinks `json:"links" api:"required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount" api:"required"`
	// The project name.
	Name string `json:"name" api:"required"`
	// The source of the project.
	Source ProjectListResponseItemsSource `json:"source" api:"required,nullable"`
	// The task type of the project.
	TaskType ProjectListResponseItemsTaskType `json:"taskType" api:"required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount" api:"required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId" api:"required,nullable" format:"uuid"`
	// The project description.
	Description string                          `json:"description" api:"nullable"`
	GitRepo     ProjectListResponseItemsGitRepo `json:"gitRepo" api:"nullable"`
	JSON        projectListResponseItemJSON     `json:"-"`
}

func (*ProjectListResponseItem) UnmarshalJSON 

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

type ProjectListResponseItemsGitRepo 

type ProjectListResponseItemsGitRepo struct {
	ID            string                              `json:"id" api:"required" format:"uuid"`
	DateConnected time.Time                           `json:"dateConnected" api:"required" format:"date-time"`
	DateUpdated   time.Time                           `json:"dateUpdated" api:"required" format:"date-time"`
	GitAccountID  string                              `json:"gitAccountId" api:"required" format:"uuid"`
	GitID         int64                               `json:"gitId" api:"required"`
	Name          string                              `json:"name" api:"required"`
	Private       bool                                `json:"private" api:"required"`
	ProjectID     string                              `json:"projectId" api:"required" format:"uuid"`
	Slug          string                              `json:"slug" api:"required"`
	URL           string                              `json:"url" api:"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" api:"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" api:"required"`
	// The task type of the project.
	TaskType param.Field[ProjectNewParamsTaskType] `json:"taskType" api:"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" api:"required" format:"uuid"`
	// The project creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The project creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The project last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of tests in the development mode of the project.
	DevelopmentGoalCount int64 `json:"developmentGoalCount" api:"required"`
	// The total number of tests in the project.
	GoalCount int64 `json:"goalCount" api:"required"`
	// The number of inference pipelines in the project.
	InferencePipelineCount int64 `json:"inferencePipelineCount" api:"required"`
	// Links to the project.
	Links ProjectNewResponseLinks `json:"links" api:"required"`
	// The number of tests in the monitoring mode of the project.
	MonitoringGoalCount int64 `json:"monitoringGoalCount" api:"required"`
	// The project name.
	Name string `json:"name" api:"required"`
	// The source of the project.
	Source ProjectNewResponseSource `json:"source" api:"required,nullable"`
	// The task type of the project.
	TaskType ProjectNewResponseTaskType `json:"taskType" api:"required"`
	// The number of versions (commits) in the project.
	VersionCount int64 `json:"versionCount" api:"required"`
	// The workspace id.
	WorkspaceID string `json:"workspaceId" api:"required,nullable" format:"uuid"`
	// The project description.
	Description string                    `json:"description" api:"nullable"`
	GitRepo     ProjectNewResponseGitRepo `json:"gitRepo" api:"nullable"`
	JSON        projectNewResponseJSON    `json:"-"`
}

func (*ProjectNewResponse) UnmarshalJSON 

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

type ProjectNewResponseGitRepo 

type ProjectNewResponseGitRepo struct {
	ID            string                        `json:"id" api:"required" format:"uuid"`
	DateConnected time.Time                     `json:"dateConnected" api:"required" format:"date-time"`
	DateUpdated   time.Time                     `json:"dateUpdated" api:"required" format:"date-time"`
	GitAccountID  string                        `json:"gitAccountId" api:"required" format:"uuid"`
	GitID         int64                         `json:"gitId" api:"required"`
	Name          string                        `json:"name" api:"required"`
	Private       bool                          `json:"private" api:"required"`
	ProjectID     string                        `json:"projectId" api:"required" format:"uuid"`
	Slug          string                        `json:"slug" api:"required"`
	URL           string                        `json:"url" api:"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" api:"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) Delete added in v0.4.1 

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

Delete a project by its ID.

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" api:"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" api:"required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount" api:"required"`
	// The test creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description" api:"required,nullable"`
	// The test name.
	Name string `json:"name" api:"required"`
	// The test number.
	Number int64 `json:"number" api:"required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId" api:"required,nullable" format:"uuid"`
	// The test subtype.
	Subtype ProjectTestListResponseItemsSubtype `json:"subtype" api:"required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                    `json:"suggested" api:"required"`
	Thresholds []ProjectTestListResponseItemsThreshold `json:"thresholds" api:"required"`
	// The test type.
	Type ProjectTestListResponseItemsType `json:"type" api:"required"`
	// Whether the test is archived.
	Archived bool `json:"archived"`
	// Whether to apply the test to all pipelines (data sources) or to a specific set
	// of pipelines. Only applies to tests that use production data.
	DefaultToAllPipelines bool `json:"defaultToAllPipelines" api:"nullable"`
	// The delay window in seconds. Only applies to tests that use production data.
	DelayWindow float64 `json:"delayWindow" api:"nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow" api:"nullable"`
	// Array of pipelines (data sources) to which the test should not be applied. Only
	// applies to tests that use production data.
	ExcludePipelines []string `json:"excludePipelines" api:"nullable" format:"uuid"`
	// Whether to include historical data in the test result. Only applies to tests
	// that use production data.
	IncludeHistoricalData bool `json:"includeHistoricalData" api:"nullable"`
	// Array of pipelines (data sources) to which the test should be applied. Only
	// applies to tests that use production data.
	IncludePipelines []string `json:"includePipelines" api:"nullable" format:"uuid"`
	// 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" api:"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" api:"required"`
	Value interface{}                                                `json:"value" api:"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" api:"required"`
	// The test name.
	Name param.Field[string] `json:"name" api:"required"`
	// The test subtype.
	Subtype    param.Field[ProjectTestNewParamsSubtype]     `json:"subtype" api:"required"`
	Thresholds param.Field[[]ProjectTestNewParamsThreshold] `json:"thresholds" api:"required"`
	// The test type.
	Type param.Field[ProjectTestNewParamsType] `json:"type" api:"required"`
	// Whether the test is archived.
	Archived param.Field[bool] `json:"archived"`
	// Whether to apply the test to all pipelines (data sources) or to a specific set
	// of pipelines. Only applies to tests that use production data.
	DefaultToAllPipelines param.Field[bool] `json:"defaultToAllPipelines"`
	// 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"`
	// Array of pipelines (data sources) to which the test should not be applied. Only
	// applies to tests that use production data.
	ExcludePipelines param.Field[[]string] `json:"excludePipelines" format:"uuid"`
	// Whether to include historical data in the test result. Only applies to tests
	// that use production data.
	IncludeHistoricalData param.Field[bool] `json:"includeHistoricalData"`
	// Array of pipelines (data sources) to which the test should be applied. Only
	// applies to tests that use production data.
	IncludePipelines param.Field[[]string] `json:"includePipelines" format:"uuid"`
	// 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" api:"required"`
	Value param.Field[interface{}] `json:"value" api:"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" api:"required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount" api:"required"`
	// The test creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description" api:"required,nullable"`
	// The test name.
	Name string `json:"name" api:"required"`
	// The test number.
	Number int64 `json:"number" api:"required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId" api:"required,nullable" format:"uuid"`
	// The test subtype.
	Subtype ProjectTestNewResponseSubtype `json:"subtype" api:"required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                              `json:"suggested" api:"required"`
	Thresholds []ProjectTestNewResponseThreshold `json:"thresholds" api:"required"`
	// The test type.
	Type ProjectTestNewResponseType `json:"type" api:"required"`
	// Whether the test is archived.
	Archived bool `json:"archived"`
	// Whether to apply the test to all pipelines (data sources) or to a specific set
	// of pipelines. Only applies to tests that use production data.
	DefaultToAllPipelines bool `json:"defaultToAllPipelines" api:"nullable"`
	// The delay window in seconds. Only applies to tests that use production data.
	DelayWindow float64 `json:"delayWindow" api:"nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow" api:"nullable"`
	// Array of pipelines (data sources) to which the test should not be applied. Only
	// applies to tests that use production data.
	ExcludePipelines []string `json:"excludePipelines" api:"nullable" format:"uuid"`
	// Whether to include historical data in the test result. Only applies to tests
	// that use production data.
	IncludeHistoricalData bool `json:"includeHistoricalData" api:"nullable"`
	// Array of pipelines (data sources) to which the test should be applied. Only
	// applies to tests that use production data.
	IncludePipelines []string `json:"includePipelines" api:"nullable" format:"uuid"`
	// 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" api:"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" api:"required"`
	Value interface{}                                          `json:"value" api:"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" api:"required"`
}

func (ProjectTestUpdateParams) MarshalJSON 

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

type ProjectTestUpdateParamsPayload 

type ProjectTestUpdateParamsPayload struct {
	ID param.Field[string] `json:"id" api:"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" api:"required"`
	Value param.Field[interface{}] `json:"value" api:"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" api:"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" api:"required"`
	// The presigned url.
	URL string `json:"url" api:"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.

type TestEvaluateParams added in v0.2.0 

type TestEvaluateParams struct {
	// End timestamp in seconds (Unix epoch)
	EndTimestamp param.Field[int64] `json:"endTimestamp" api:"required"`
	// Start timestamp in seconds (Unix epoch)
	StartTimestamp param.Field[int64] `json:"startTimestamp" api:"required"`
	// ID of the inference pipeline to evaluate. If not provided, all inference
	// pipelines the test applies to will be evaluated.
	InferencePipelineID param.Field[string] `json:"inferencePipelineId" format:"uuid"`
	// Whether to overwrite existing test results
	OverwriteResults param.Field[bool] `json:"overwriteResults"`
}

func (TestEvaluateParams) MarshalJSON added in v0.2.0 

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

type TestEvaluateResponse added in v0.2.0 

type TestEvaluateResponse struct {
	Message string `json:"message" api:"required"`
	// Number of inference pipelines the test was queued for evaluation on
	PipelineCount int64 `json:"pipelineCount" api:"required"`
	// The end timestamp you requested (in seconds)
	RequestedEndTimestamp int64 `json:"requestedEndTimestamp" api:"required"`
	// The start timestamp you requested (in seconds)
	RequestedStartTimestamp int64 `json:"requestedStartTimestamp" api:"required"`
	// Array of background task information for each pipeline evaluation
	Tasks []TestEvaluateResponseTask `json:"tasks" api:"required"`
	JSON  testEvaluateResponseJSON   `json:"-"`
}

func (*TestEvaluateResponse) UnmarshalJSON added in v0.2.0 

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

type TestEvaluateResponseTask added in v0.2.0 

type TestEvaluateResponseTask struct {
	// ID of the inference pipeline this task is for
	PipelineID string `json:"pipelineId" api:"required" format:"uuid"`
	// ID of the background task
	TaskResultID string `json:"taskResultId" api:"required" format:"uuid"`
	// URL to check the status of this background task
	TaskResultURL string                       `json:"taskResultUrl" api:"required"`
	JSON          testEvaluateResponseTaskJSON `json:"-"`
}

func (*TestEvaluateResponseTask) UnmarshalJSON added in v0.2.0 

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

type TestListResultsParams added in v0.4.0 

type TestListResultsParams struct {
	// Filter for results that use data starting before the end timestamp.
	EndTimestamp param.Field[float64] `query:"endTimestamp"`
	// Include the insights linked to each test result
	IncludeInsights param.Field[bool] `query:"includeInsights"`
	// Retrive test results for a specific inference pipeline.
	InferencePipelineID param.Field[string] `query:"inferencePipelineId" 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"`
	// Retrive test results for a specific project version.
	ProjectVersionID param.Field[string] `query:"projectVersionId" format:"uuid"`
	// Filter for results that use data ending after the start timestamp.
	StartTimestamp param.Field[float64] `query:"startTimestamp"`
	// Filter by status(es).
	Status param.Field[[]string] `query:"status"`
}

func (TestListResultsParams) URLQuery added in v0.4.0 

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

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

type TestListResultsResponse added in v0.4.0 

type TestListResultsResponse struct {
	Items               []TestListResultsResponseItem              `json:"items" api:"required"`
	LastUnskippedResult TestListResultsResponseLastUnskippedResult `json:"lastUnskippedResult" api:"nullable"`
	JSON                testListResultsResponseJSON                `json:"-"`
}

func (*TestListResultsResponse) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItem added in v0.4.0 

type TestListResultsResponseItem struct {
	// Project version (commit) id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The data end date.
	DateDataEnds time.Time `json:"dateDataEnds" api:"required,nullable" format:"date-time"`
	// The data start date.
	DateDataStarts time.Time `json:"dateDataStarts" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline id.
	InferencePipelineID string `json:"inferencePipelineId" api:"required,nullable" format:"uuid"`
	// The project version (commit) id.
	ProjectVersionID string `json:"projectVersionId" api:"required,nullable" format:"uuid"`
	// The status of the test.
	Status TestListResultsResponseItemsStatus `json:"status" api:"required"`
	// The status message.
	StatusMessage  string                                      `json:"statusMessage" api:"required,nullable"`
	ExpectedValues []TestListResultsResponseItemsExpectedValue `json:"expectedValues"`
	Goal           TestListResultsResponseItemsGoal            `json:"goal"`
	// The test id.
	GoalID string `json:"goalId" api:"nullable" format:"uuid"`
	// The URL to the rows of the test result.
	Rows string `json:"rows"`
	// The body of the rows request.
	RowsBody TestListResultsResponseItemsRowsBody `json:"rowsBody" api:"nullable"`
	JSON     testListResultsResponseItemJSON      `json:"-"`
}

func (*TestListResultsResponseItem) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsExpectedValue added in v0.4.0 

type TestListResultsResponseItemsExpectedValue struct {
	// the lower threshold for the expected value
	LowerThreshold float64 `json:"lowerThreshold" api:"nullable"`
	// One of the `measurement` values in the test's thresholds
	Measurement string `json:"measurement"`
	// The upper threshold for the expected value
	UpperThreshold float64                                       `json:"upperThreshold" api:"nullable"`
	JSON           testListResultsResponseItemsExpectedValueJSON `json:"-"`
}

func (*TestListResultsResponseItemsExpectedValue) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsGoal added in v0.4.0 

type TestListResultsResponseItemsGoal struct {
	// The test id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount" api:"required"`
	// The test creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description" api:"required,nullable"`
	// The test name.
	Name string `json:"name" api:"required"`
	// The test number.
	Number int64 `json:"number" api:"required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId" api:"required,nullable" format:"uuid"`
	// The test subtype.
	Subtype TestListResultsResponseItemsGoalSubtype `json:"subtype" api:"required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                        `json:"suggested" api:"required"`
	Thresholds []TestListResultsResponseItemsGoalThreshold `json:"thresholds" api:"required"`
	// The test type.
	Type TestListResultsResponseItemsGoalType `json:"type" api:"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" api:"nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow" api:"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                  testListResultsResponseItemsGoalJSON `json:"-"`
}

func (*TestListResultsResponseItemsGoal) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsGoalSubtype added in v0.4.0 

type TestListResultsResponseItemsGoalSubtype string

The test subtype. 

const (
	TestListResultsResponseItemsGoalSubtypeAnomalousColumnCount       TestListResultsResponseItemsGoalSubtype = "anomalousColumnCount"
	TestListResultsResponseItemsGoalSubtypeCharacterLength            TestListResultsResponseItemsGoalSubtype = "characterLength"
	TestListResultsResponseItemsGoalSubtypeClassImbalanceRatio        TestListResultsResponseItemsGoalSubtype = "classImbalanceRatio"
	TestListResultsResponseItemsGoalSubtypeExpectColumnAToBeInColumnB TestListResultsResponseItemsGoalSubtype = "expectColumnAToBeInColumnB"
	TestListResultsResponseItemsGoalSubtypeColumnAverage              TestListResultsResponseItemsGoalSubtype = "columnAverage"
	TestListResultsResponseItemsGoalSubtypeColumnDrift                TestListResultsResponseItemsGoalSubtype = "columnDrift"
	TestListResultsResponseItemsGoalSubtypeColumnStatistic            TestListResultsResponseItemsGoalSubtype = "columnStatistic"
	TestListResultsResponseItemsGoalSubtypeColumnValuesMatch          TestListResultsResponseItemsGoalSubtype = "columnValuesMatch"
	TestListResultsResponseItemsGoalSubtypeConflictingLabelRowCount   TestListResultsResponseItemsGoalSubtype = "conflictingLabelRowCount"
	TestListResultsResponseItemsGoalSubtypeContainsPii                TestListResultsResponseItemsGoalSubtype = "containsPii"
	TestListResultsResponseItemsGoalSubtypeContainsValidURL           TestListResultsResponseItemsGoalSubtype = "containsValidUrl"
	TestListResultsResponseItemsGoalSubtypeCorrelatedFeatureCount     TestListResultsResponseItemsGoalSubtype = "correlatedFeatureCount"
	TestListResultsResponseItemsGoalSubtypeCustomMetricThreshold      TestListResultsResponseItemsGoalSubtype = "customMetricThreshold"
	TestListResultsResponseItemsGoalSubtypeDuplicateRowCount          TestListResultsResponseItemsGoalSubtype = "duplicateRowCount"
	TestListResultsResponseItemsGoalSubtypeEmptyFeature               TestListResultsResponseItemsGoalSubtype = "emptyFeature"
	TestListResultsResponseItemsGoalSubtypeEmptyFeatureCount          TestListResultsResponseItemsGoalSubtype = "emptyFeatureCount"
	TestListResultsResponseItemsGoalSubtypeDriftedFeatureCount        TestListResultsResponseItemsGoalSubtype = "driftedFeatureCount"
	TestListResultsResponseItemsGoalSubtypeFeatureMissingValues       TestListResultsResponseItemsGoalSubtype = "featureMissingValues"
	TestListResultsResponseItemsGoalSubtypeFeatureValueValidation     TestListResultsResponseItemsGoalSubtype = "featureValueValidation"
	TestListResultsResponseItemsGoalSubtypeGreatExpectations          TestListResultsResponseItemsGoalSubtype = "greatExpectations"
	TestListResultsResponseItemsGoalSubtypeGroupByColumnStatsCheck    TestListResultsResponseItemsGoalSubtype = "groupByColumnStatsCheck"
	TestListResultsResponseItemsGoalSubtypeIllFormedRowCount          TestListResultsResponseItemsGoalSubtype = "illFormedRowCount"
	TestListResultsResponseItemsGoalSubtypeIsCode                     TestListResultsResponseItemsGoalSubtype = "isCode"
	TestListResultsResponseItemsGoalSubtypeIsJson                     TestListResultsResponseItemsGoalSubtype = "isJson"
	TestListResultsResponseItemsGoalSubtypeLlmRubricThresholdV2       TestListResultsResponseItemsGoalSubtype = "llmRubricThresholdV2"
	TestListResultsResponseItemsGoalSubtypeLabelDrift                 TestListResultsResponseItemsGoalSubtype = "labelDrift"
	TestListResultsResponseItemsGoalSubtypeMetricThreshold            TestListResultsResponseItemsGoalSubtype = "metricThreshold"
	TestListResultsResponseItemsGoalSubtypeNewCategoryCount           TestListResultsResponseItemsGoalSubtype = "newCategoryCount"
	TestListResultsResponseItemsGoalSubtypeNewLabelCount              TestListResultsResponseItemsGoalSubtype = "newLabelCount"
	TestListResultsResponseItemsGoalSubtypeNullRowCount               TestListResultsResponseItemsGoalSubtype = "nullRowCount"
	TestListResultsResponseItemsGoalSubtypeRowCount                   TestListResultsResponseItemsGoalSubtype = "rowCount"
	TestListResultsResponseItemsGoalSubtypePpScoreValueValidation     TestListResultsResponseItemsGoalSubtype = "ppScoreValueValidation"
	TestListResultsResponseItemsGoalSubtypeQuasiConstantFeature       TestListResultsResponseItemsGoalSubtype = "quasiConstantFeature"
	TestListResultsResponseItemsGoalSubtypeQuasiConstantFeatureCount  TestListResultsResponseItemsGoalSubtype = "quasiConstantFeatureCount"
	TestListResultsResponseItemsGoalSubtypeSqlQuery                   TestListResultsResponseItemsGoalSubtype = "sqlQuery"
	TestListResultsResponseItemsGoalSubtypeDtypeValidation            TestListResultsResponseItemsGoalSubtype = "dtypeValidation"
	TestListResultsResponseItemsGoalSubtypeSentenceLength             TestListResultsResponseItemsGoalSubtype = "sentenceLength"
	TestListResultsResponseItemsGoalSubtypeSizeRatio                  TestListResultsResponseItemsGoalSubtype = "sizeRatio"
	TestListResultsResponseItemsGoalSubtypeSpecialCharactersRatio     TestListResultsResponseItemsGoalSubtype = "specialCharactersRatio"
	TestListResultsResponseItemsGoalSubtypeStringValidation           TestListResultsResponseItemsGoalSubtype = "stringValidation"
	TestListResultsResponseItemsGoalSubtypeTrainValLeakageRowCount    TestListResultsResponseItemsGoalSubtype = "trainValLeakageRowCount"
)

func (TestListResultsResponseItemsGoalSubtype) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsGoalSubtype) IsKnown() bool

type TestListResultsResponseItemsGoalThreshold added in v0.4.0 

type TestListResultsResponseItemsGoalThreshold struct {
	// The insight name to be evaluated.
	InsightName TestListResultsResponseItemsGoalThresholdsInsightName `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 []TestListResultsResponseItemsGoalThresholdsInsightParameter `json:"insightParameters" api:"nullable"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator TestListResultsResponseItemsGoalThresholdsOperator `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode TestListResultsResponseItemsGoalThresholdsThresholdMode `json:"thresholdMode"`
	// The value to be compared.
	Value TestListResultsResponseItemsGoalThresholdsValueUnion `json:"value"`
	JSON  testListResultsResponseItemsGoalThresholdJSON        `json:"-"`
}

func (*TestListResultsResponseItemsGoalThreshold) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsGoalThresholdsInsightName added in v0.4.0 

type TestListResultsResponseItemsGoalThresholdsInsightName string

The insight name to be evaluated. 

const (
	TestListResultsResponseItemsGoalThresholdsInsightNameCharacterLength            TestListResultsResponseItemsGoalThresholdsInsightName = "characterLength"
	TestListResultsResponseItemsGoalThresholdsInsightNameClassImbalance             TestListResultsResponseItemsGoalThresholdsInsightName = "classImbalance"
	TestListResultsResponseItemsGoalThresholdsInsightNameExpectColumnAToBeInColumnB TestListResultsResponseItemsGoalThresholdsInsightName = "expectColumnAToBeInColumnB"
	TestListResultsResponseItemsGoalThresholdsInsightNameColumnAverage              TestListResultsResponseItemsGoalThresholdsInsightName = "columnAverage"
	TestListResultsResponseItemsGoalThresholdsInsightNameColumnDrift                TestListResultsResponseItemsGoalThresholdsInsightName = "columnDrift"
	TestListResultsResponseItemsGoalThresholdsInsightNameColumnValuesMatch          TestListResultsResponseItemsGoalThresholdsInsightName = "columnValuesMatch"
	TestListResultsResponseItemsGoalThresholdsInsightNameConfidenceDistribution     TestListResultsResponseItemsGoalThresholdsInsightName = "confidenceDistribution"
	TestListResultsResponseItemsGoalThresholdsInsightNameConflictingLabelRowCount   TestListResultsResponseItemsGoalThresholdsInsightName = "conflictingLabelRowCount"
	TestListResultsResponseItemsGoalThresholdsInsightNameContainsPii                TestListResultsResponseItemsGoalThresholdsInsightName = "containsPii"
	TestListResultsResponseItemsGoalThresholdsInsightNameContainsValidURL           TestListResultsResponseItemsGoalThresholdsInsightName = "containsValidUrl"
	TestListResultsResponseItemsGoalThresholdsInsightNameCorrelatedFeatures         TestListResultsResponseItemsGoalThresholdsInsightName = "correlatedFeatures"
	TestListResultsResponseItemsGoalThresholdsInsightNameCustomMetric               TestListResultsResponseItemsGoalThresholdsInsightName = "customMetric"
	TestListResultsResponseItemsGoalThresholdsInsightNameDuplicateRowCount          TestListResultsResponseItemsGoalThresholdsInsightName = "duplicateRowCount"
	TestListResultsResponseItemsGoalThresholdsInsightNameEmptyFeatures              TestListResultsResponseItemsGoalThresholdsInsightName = "emptyFeatures"
	TestListResultsResponseItemsGoalThresholdsInsightNameFeatureDrift               TestListResultsResponseItemsGoalThresholdsInsightName = "featureDrift"
	TestListResultsResponseItemsGoalThresholdsInsightNameFeatureProfile             TestListResultsResponseItemsGoalThresholdsInsightName = "featureProfile"
	TestListResultsResponseItemsGoalThresholdsInsightNameGreatExpectations          TestListResultsResponseItemsGoalThresholdsInsightName = "greatExpectations"
	TestListResultsResponseItemsGoalThresholdsInsightNameGroupByColumnStatsCheck    TestListResultsResponseItemsGoalThresholdsInsightName = "groupByColumnStatsCheck"
	TestListResultsResponseItemsGoalThresholdsInsightNameIllFormedRowCount          TestListResultsResponseItemsGoalThresholdsInsightName = "illFormedRowCount"
	TestListResultsResponseItemsGoalThresholdsInsightNameIsCode                     TestListResultsResponseItemsGoalThresholdsInsightName = "isCode"
	TestListResultsResponseItemsGoalThresholdsInsightNameIsJson                     TestListResultsResponseItemsGoalThresholdsInsightName = "isJson"
	TestListResultsResponseItemsGoalThresholdsInsightNameLlmRubricV2                TestListResultsResponseItemsGoalThresholdsInsightName = "llmRubricV2"
	TestListResultsResponseItemsGoalThresholdsInsightNameLabelDrift                 TestListResultsResponseItemsGoalThresholdsInsightName = "labelDrift"
	TestListResultsResponseItemsGoalThresholdsInsightNameMetrics                    TestListResultsResponseItemsGoalThresholdsInsightName = "metrics"
	TestListResultsResponseItemsGoalThresholdsInsightNameNewCategories              TestListResultsResponseItemsGoalThresholdsInsightName = "newCategories"
	TestListResultsResponseItemsGoalThresholdsInsightNameNewLabels                  TestListResultsResponseItemsGoalThresholdsInsightName = "newLabels"
	TestListResultsResponseItemsGoalThresholdsInsightNameNullRowCount               TestListResultsResponseItemsGoalThresholdsInsightName = "nullRowCount"
	TestListResultsResponseItemsGoalThresholdsInsightNamePpScore                    TestListResultsResponseItemsGoalThresholdsInsightName = "ppScore"
	TestListResultsResponseItemsGoalThresholdsInsightNameQuasiConstantFeatures      TestListResultsResponseItemsGoalThresholdsInsightName = "quasiConstantFeatures"
	TestListResultsResponseItemsGoalThresholdsInsightNameSentenceLength             TestListResultsResponseItemsGoalThresholdsInsightName = "sentenceLength"
	TestListResultsResponseItemsGoalThresholdsInsightNameSizeRatio                  TestListResultsResponseItemsGoalThresholdsInsightName = "sizeRatio"
	TestListResultsResponseItemsGoalThresholdsInsightNameSpecialCharacters          TestListResultsResponseItemsGoalThresholdsInsightName = "specialCharacters"
	TestListResultsResponseItemsGoalThresholdsInsightNameStringValidation           TestListResultsResponseItemsGoalThresholdsInsightName = "stringValidation"
	TestListResultsResponseItemsGoalThresholdsInsightNameTrainValLeakageRowCount    TestListResultsResponseItemsGoalThresholdsInsightName = "trainValLeakageRowCount"
)

func (TestListResultsResponseItemsGoalThresholdsInsightName) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsGoalThresholdsInsightName) IsKnown() bool

type TestListResultsResponseItemsGoalThresholdsInsightParameter added in v0.4.0 

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

func (*TestListResultsResponseItemsGoalThresholdsInsightParameter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsGoalThresholdsOperator added in v0.4.0 

type TestListResultsResponseItemsGoalThresholdsOperator string

The operator to be used for the evaluation. 

const (
	TestListResultsResponseItemsGoalThresholdsOperatorIs              TestListResultsResponseItemsGoalThresholdsOperator = "is"
	TestListResultsResponseItemsGoalThresholdsOperatorGreater         TestListResultsResponseItemsGoalThresholdsOperator = ">"
	TestListResultsResponseItemsGoalThresholdsOperatorGreaterOrEquals TestListResultsResponseItemsGoalThresholdsOperator = ">="
	TestListResultsResponseItemsGoalThresholdsOperatorLess            TestListResultsResponseItemsGoalThresholdsOperator = "<"
	TestListResultsResponseItemsGoalThresholdsOperatorLessOrEquals    TestListResultsResponseItemsGoalThresholdsOperator = "<="
	TestListResultsResponseItemsGoalThresholdsOperatorNotEquals       TestListResultsResponseItemsGoalThresholdsOperator = "!="
)

func (TestListResultsResponseItemsGoalThresholdsOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsGoalThresholdsOperator) IsKnown() bool

type TestListResultsResponseItemsGoalThresholdsThresholdMode added in v0.4.0 

type TestListResultsResponseItemsGoalThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	TestListResultsResponseItemsGoalThresholdsThresholdModeAutomatic TestListResultsResponseItemsGoalThresholdsThresholdMode = "automatic"
	TestListResultsResponseItemsGoalThresholdsThresholdModeManual    TestListResultsResponseItemsGoalThresholdsThresholdMode = "manual"
)

func (TestListResultsResponseItemsGoalThresholdsThresholdMode) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsGoalThresholdsThresholdMode) IsKnown() bool

type TestListResultsResponseItemsGoalThresholdsValueArray added in v0.4.0 

type TestListResultsResponseItemsGoalThresholdsValueArray []string

func (TestListResultsResponseItemsGoalThresholdsValueArray) ImplementsTestListResultsResponseItemsGoalThresholdsValueUnion added in v0.4.0 

func (r TestListResultsResponseItemsGoalThresholdsValueArray) ImplementsTestListResultsResponseItemsGoalThresholdsValueUnion()

type TestListResultsResponseItemsGoalThresholdsValueUnion added in v0.4.0 

type TestListResultsResponseItemsGoalThresholdsValueUnion interface {
	ImplementsTestListResultsResponseItemsGoalThresholdsValueUnion()
}

The value to be compared.

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

type TestListResultsResponseItemsGoalType added in v0.4.0 

type TestListResultsResponseItemsGoalType string

The test type. 

const (
	TestListResultsResponseItemsGoalTypeIntegrity   TestListResultsResponseItemsGoalType = "integrity"
	TestListResultsResponseItemsGoalTypeConsistency TestListResultsResponseItemsGoalType = "consistency"
	TestListResultsResponseItemsGoalTypePerformance TestListResultsResponseItemsGoalType = "performance"
)

func (TestListResultsResponseItemsGoalType) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsGoalType) IsKnown() bool

type TestListResultsResponseItemsRowsBody added in v0.4.0 

type TestListResultsResponseItemsRowsBody struct {
	ColumnFilters     []TestListResultsResponseItemsRowsBodyColumnFilter `json:"columnFilters" api:"nullable"`
	ExcludeRowIDList  []int64                                            `json:"excludeRowIdList" api:"nullable"`
	NotSearchQueryAnd []string                                           `json:"notSearchQueryAnd" api:"nullable"`
	NotSearchQueryOr  []string                                           `json:"notSearchQueryOr" api:"nullable"`
	RowIDList         []int64                                            `json:"rowIdList" api:"nullable"`
	SearchQueryAnd    []string                                           `json:"searchQueryAnd" api:"nullable"`
	SearchQueryOr     []string                                           `json:"searchQueryOr" api:"nullable"`
	JSON              testListResultsResponseItemsRowsBodyJSON           `json:"-"`
}

The body of the rows request.

func (*TestListResultsResponseItemsRowsBody) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsRowsBodyColumnFilter added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFilter struct {
	// The name of the column.
	Measurement string                                                    `json:"measurement" api:"required"`
	Operator    TestListResultsResponseItemsRowsBodyColumnFiltersOperator `json:"operator" api:"required"`
	// This field can have the runtime type of
	// [[]TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion],
	// [float64],
	// [TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion].
	Value interface{}                                          `json:"value" api:"required"`
	JSON  testListResultsResponseItemsRowsBodyColumnFilterJSON `json:"-"`
	// contains filtered or unexported fields
}

func (TestListResultsResponseItemsRowsBodyColumnFilter) AsUnion added in v0.4.0 

func (r TestListResultsResponseItemsRowsBodyColumnFilter) AsUnion() TestListResultsResponseItemsRowsBodyColumnFiltersUnion

AsUnion returns a TestListResultsResponseItemsRowsBodyColumnFiltersUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilter, TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilter, TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilter.

func (*TestListResultsResponseItemsRowsBodyColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilter added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilter struct {
	// The name of the column.
	Measurement string                                                                       `json:"measurement" api:"required"`
	Operator    TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator `json:"operator" api:"required"`
	Value       float64                                                                      `json:"value" api:"required,nullable"`
	JSON        testListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterJSON     `json:"-"`
}

func (*TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator string
const (
	TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorGreater         TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = ">"
	TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorGreaterOrEquals TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = ">="
	TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorIs              TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "is"
	TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorLess            TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "<"
	TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorLessOrEquals    TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "<="
	TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperatorNotEquals       TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator = "!="
)

func (TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown() bool

type TestListResultsResponseItemsRowsBodyColumnFiltersOperator added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersOperator string
const (
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorContainsNone    TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "contains_none"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorContainsAny     TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "contains_any"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorContainsAll     TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "contains_all"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorOneOf           TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "one_of"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorNoneOf          TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "none_of"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorGreater         TestListResultsResponseItemsRowsBodyColumnFiltersOperator = ">"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorGreaterOrEquals TestListResultsResponseItemsRowsBodyColumnFiltersOperator = ">="
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorIs              TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "is"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorLess            TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "<"
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorLessOrEquals    TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "<="
	TestListResultsResponseItemsRowsBodyColumnFiltersOperatorNotEquals       TestListResultsResponseItemsRowsBodyColumnFiltersOperator = "!="
)

func (TestListResultsResponseItemsRowsBodyColumnFiltersOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsRowsBodyColumnFiltersOperator) IsKnown() bool

type TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilter added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilter struct {
	// The name of the column.
	Measurement string                                                                       `json:"measurement" api:"required"`
	Operator    TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator     `json:"operator" api:"required"`
	Value       []TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion `json:"value" api:"required"`
	JSON        testListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterJSON         `json:"-"`
}

func (*TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator string
const (
	TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsNone TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_none"
	TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsAny  TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_any"
	TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorContainsAll  TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "contains_all"
	TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorOneOf        TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "one_of"
	TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperatorNoneOf       TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator = "none_of"
)

func (TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown() bool

type TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion interface {
	ImplementsTestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionFloat.

type TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilter added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilter struct {
	// The name of the column.
	Measurement string                                                                        `json:"measurement" api:"required"`
	Operator    TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator   `json:"operator" api:"required"`
	Value       TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion `json:"value" api:"required"`
	JSON        testListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterJSON       `json:"-"`
}

func (*TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator string
const (
	TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperatorIs        TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator = "is"
	TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperatorNotEquals TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator = "!="
)

func (TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown() bool

type TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion added in v0.4.0 

type TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion interface {
	ImplementsTestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionBool.

type TestListResultsResponseItemsRowsBodyColumnFiltersUnion added in v0.4.0 

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

Union satisfied by TestListResultsResponseItemsRowsBodyColumnFiltersSetColumnFilter, TestListResultsResponseItemsRowsBodyColumnFiltersNumericColumnFilter or TestListResultsResponseItemsRowsBodyColumnFiltersStringColumnFilter.

type TestListResultsResponseItemsStatus added in v0.4.0 

type TestListResultsResponseItemsStatus string

The status of the test. 

const (
	TestListResultsResponseItemsStatusRunning TestListResultsResponseItemsStatus = "running"
	TestListResultsResponseItemsStatusPassing TestListResultsResponseItemsStatus = "passing"
	TestListResultsResponseItemsStatusFailing TestListResultsResponseItemsStatus = "failing"
	TestListResultsResponseItemsStatusSkipped TestListResultsResponseItemsStatus = "skipped"
	TestListResultsResponseItemsStatusError   TestListResultsResponseItemsStatus = "error"
)

func (TestListResultsResponseItemsStatus) IsKnown added in v0.4.0 

func (r TestListResultsResponseItemsStatus) IsKnown() bool

type TestListResultsResponseLastUnskippedResult added in v0.4.0 

type TestListResultsResponseLastUnskippedResult struct {
	// Project version (commit) id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The data end date.
	DateDataEnds time.Time `json:"dateDataEnds" api:"required,nullable" format:"date-time"`
	// The data start date.
	DateDataStarts time.Time `json:"dateDataStarts" api:"required,nullable" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The inference pipeline id.
	InferencePipelineID string `json:"inferencePipelineId" api:"required,nullable" format:"uuid"`
	// The project version (commit) id.
	ProjectVersionID string `json:"projectVersionId" api:"required,nullable" format:"uuid"`
	// The status of the test.
	Status TestListResultsResponseLastUnskippedResultStatus `json:"status" api:"required"`
	// The status message.
	StatusMessage  string                                                    `json:"statusMessage" api:"required,nullable"`
	ExpectedValues []TestListResultsResponseLastUnskippedResultExpectedValue `json:"expectedValues"`
	Goal           TestListResultsResponseLastUnskippedResultGoal            `json:"goal"`
	// The test id.
	GoalID string `json:"goalId" api:"nullable" format:"uuid"`
	// The URL to the rows of the test result.
	Rows string `json:"rows"`
	// The body of the rows request.
	RowsBody TestListResultsResponseLastUnskippedResultRowsBody `json:"rowsBody" api:"nullable"`
	JSON     testListResultsResponseLastUnskippedResultJSON     `json:"-"`
}

func (*TestListResultsResponseLastUnskippedResult) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultExpectedValue added in v0.4.0 

type TestListResultsResponseLastUnskippedResultExpectedValue struct {
	// the lower threshold for the expected value
	LowerThreshold float64 `json:"lowerThreshold" api:"nullable"`
	// One of the `measurement` values in the test's thresholds
	Measurement string `json:"measurement"`
	// The upper threshold for the expected value
	UpperThreshold float64                                                     `json:"upperThreshold" api:"nullable"`
	JSON           testListResultsResponseLastUnskippedResultExpectedValueJSON `json:"-"`
}

func (*TestListResultsResponseLastUnskippedResultExpectedValue) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultGoal added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoal struct {
	// The test id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The number of comments on the test.
	CommentCount int64 `json:"commentCount" api:"required"`
	// The test creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The date the test was archived.
	DateArchived time.Time `json:"dateArchived" api:"required,nullable" format:"date-time"`
	// The creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The test description.
	Description interface{} `json:"description" api:"required,nullable"`
	// The test name.
	Name string `json:"name" api:"required"`
	// The test number.
	Number int64 `json:"number" api:"required"`
	// The project version (commit) id where the test was created.
	OriginProjectVersionID string `json:"originProjectVersionId" api:"required,nullable" format:"uuid"`
	// The test subtype.
	Subtype TestListResultsResponseLastUnskippedResultGoalSubtype `json:"subtype" api:"required"`
	// Whether the test is suggested or user-created.
	Suggested  bool                                                      `json:"suggested" api:"required"`
	Thresholds []TestListResultsResponseLastUnskippedResultGoalThreshold `json:"thresholds" api:"required"`
	// The test type.
	Type TestListResultsResponseLastUnskippedResultGoalType `json:"type" api:"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" api:"nullable"`
	// The evaluation window in seconds. Only applies to tests that use production
	// data.
	EvaluationWindow float64 `json:"evaluationWindow" api:"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                  testListResultsResponseLastUnskippedResultGoalJSON `json:"-"`
}

func (*TestListResultsResponseLastUnskippedResultGoal) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultGoalSubtype added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalSubtype string

The test subtype. 

const (
	TestListResultsResponseLastUnskippedResultGoalSubtypeAnomalousColumnCount       TestListResultsResponseLastUnskippedResultGoalSubtype = "anomalousColumnCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeCharacterLength            TestListResultsResponseLastUnskippedResultGoalSubtype = "characterLength"
	TestListResultsResponseLastUnskippedResultGoalSubtypeClassImbalanceRatio        TestListResultsResponseLastUnskippedResultGoalSubtype = "classImbalanceRatio"
	TestListResultsResponseLastUnskippedResultGoalSubtypeExpectColumnAToBeInColumnB TestListResultsResponseLastUnskippedResultGoalSubtype = "expectColumnAToBeInColumnB"
	TestListResultsResponseLastUnskippedResultGoalSubtypeColumnAverage              TestListResultsResponseLastUnskippedResultGoalSubtype = "columnAverage"
	TestListResultsResponseLastUnskippedResultGoalSubtypeColumnDrift                TestListResultsResponseLastUnskippedResultGoalSubtype = "columnDrift"
	TestListResultsResponseLastUnskippedResultGoalSubtypeColumnStatistic            TestListResultsResponseLastUnskippedResultGoalSubtype = "columnStatistic"
	TestListResultsResponseLastUnskippedResultGoalSubtypeColumnValuesMatch          TestListResultsResponseLastUnskippedResultGoalSubtype = "columnValuesMatch"
	TestListResultsResponseLastUnskippedResultGoalSubtypeConflictingLabelRowCount   TestListResultsResponseLastUnskippedResultGoalSubtype = "conflictingLabelRowCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeContainsPii                TestListResultsResponseLastUnskippedResultGoalSubtype = "containsPii"
	TestListResultsResponseLastUnskippedResultGoalSubtypeContainsValidURL           TestListResultsResponseLastUnskippedResultGoalSubtype = "containsValidUrl"
	TestListResultsResponseLastUnskippedResultGoalSubtypeCorrelatedFeatureCount     TestListResultsResponseLastUnskippedResultGoalSubtype = "correlatedFeatureCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeCustomMetricThreshold      TestListResultsResponseLastUnskippedResultGoalSubtype = "customMetricThreshold"
	TestListResultsResponseLastUnskippedResultGoalSubtypeDuplicateRowCount          TestListResultsResponseLastUnskippedResultGoalSubtype = "duplicateRowCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeEmptyFeature               TestListResultsResponseLastUnskippedResultGoalSubtype = "emptyFeature"
	TestListResultsResponseLastUnskippedResultGoalSubtypeEmptyFeatureCount          TestListResultsResponseLastUnskippedResultGoalSubtype = "emptyFeatureCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeDriftedFeatureCount        TestListResultsResponseLastUnskippedResultGoalSubtype = "driftedFeatureCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeFeatureMissingValues       TestListResultsResponseLastUnskippedResultGoalSubtype = "featureMissingValues"
	TestListResultsResponseLastUnskippedResultGoalSubtypeFeatureValueValidation     TestListResultsResponseLastUnskippedResultGoalSubtype = "featureValueValidation"
	TestListResultsResponseLastUnskippedResultGoalSubtypeGreatExpectations          TestListResultsResponseLastUnskippedResultGoalSubtype = "greatExpectations"
	TestListResultsResponseLastUnskippedResultGoalSubtypeGroupByColumnStatsCheck    TestListResultsResponseLastUnskippedResultGoalSubtype = "groupByColumnStatsCheck"
	TestListResultsResponseLastUnskippedResultGoalSubtypeIllFormedRowCount          TestListResultsResponseLastUnskippedResultGoalSubtype = "illFormedRowCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeIsCode                     TestListResultsResponseLastUnskippedResultGoalSubtype = "isCode"
	TestListResultsResponseLastUnskippedResultGoalSubtypeIsJson                     TestListResultsResponseLastUnskippedResultGoalSubtype = "isJson"
	TestListResultsResponseLastUnskippedResultGoalSubtypeLlmRubricThresholdV2       TestListResultsResponseLastUnskippedResultGoalSubtype = "llmRubricThresholdV2"
	TestListResultsResponseLastUnskippedResultGoalSubtypeLabelDrift                 TestListResultsResponseLastUnskippedResultGoalSubtype = "labelDrift"
	TestListResultsResponseLastUnskippedResultGoalSubtypeMetricThreshold            TestListResultsResponseLastUnskippedResultGoalSubtype = "metricThreshold"
	TestListResultsResponseLastUnskippedResultGoalSubtypeNewCategoryCount           TestListResultsResponseLastUnskippedResultGoalSubtype = "newCategoryCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeNewLabelCount              TestListResultsResponseLastUnskippedResultGoalSubtype = "newLabelCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeNullRowCount               TestListResultsResponseLastUnskippedResultGoalSubtype = "nullRowCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeRowCount                   TestListResultsResponseLastUnskippedResultGoalSubtype = "rowCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypePpScoreValueValidation     TestListResultsResponseLastUnskippedResultGoalSubtype = "ppScoreValueValidation"
	TestListResultsResponseLastUnskippedResultGoalSubtypeQuasiConstantFeature       TestListResultsResponseLastUnskippedResultGoalSubtype = "quasiConstantFeature"
	TestListResultsResponseLastUnskippedResultGoalSubtypeQuasiConstantFeatureCount  TestListResultsResponseLastUnskippedResultGoalSubtype = "quasiConstantFeatureCount"
	TestListResultsResponseLastUnskippedResultGoalSubtypeSqlQuery                   TestListResultsResponseLastUnskippedResultGoalSubtype = "sqlQuery"
	TestListResultsResponseLastUnskippedResultGoalSubtypeDtypeValidation            TestListResultsResponseLastUnskippedResultGoalSubtype = "dtypeValidation"
	TestListResultsResponseLastUnskippedResultGoalSubtypeSentenceLength             TestListResultsResponseLastUnskippedResultGoalSubtype = "sentenceLength"
	TestListResultsResponseLastUnskippedResultGoalSubtypeSizeRatio                  TestListResultsResponseLastUnskippedResultGoalSubtype = "sizeRatio"
	TestListResultsResponseLastUnskippedResultGoalSubtypeSpecialCharactersRatio     TestListResultsResponseLastUnskippedResultGoalSubtype = "specialCharactersRatio"
	TestListResultsResponseLastUnskippedResultGoalSubtypeStringValidation           TestListResultsResponseLastUnskippedResultGoalSubtype = "stringValidation"
	TestListResultsResponseLastUnskippedResultGoalSubtypeTrainValLeakageRowCount    TestListResultsResponseLastUnskippedResultGoalSubtype = "trainValLeakageRowCount"
)

func (TestListResultsResponseLastUnskippedResultGoalSubtype) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultGoalSubtype) IsKnown() bool

type TestListResultsResponseLastUnskippedResultGoalThreshold added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalThreshold struct {
	// The insight name to be evaluated.
	InsightName TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName `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 []TestListResultsResponseLastUnskippedResultGoalThresholdsInsightParameter `json:"insightParameters" api:"nullable"`
	// The measurement to be evaluated.
	Measurement string `json:"measurement"`
	// The operator to be used for the evaluation.
	Operator TestListResultsResponseLastUnskippedResultGoalThresholdsOperator `json:"operator"`
	// Whether to use automatic anomaly detection or manual thresholds
	ThresholdMode TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdMode `json:"thresholdMode"`
	// The value to be compared.
	Value TestListResultsResponseLastUnskippedResultGoalThresholdsValueUnion `json:"value"`
	JSON  testListResultsResponseLastUnskippedResultGoalThresholdJSON        `json:"-"`
}

func (*TestListResultsResponseLastUnskippedResultGoalThreshold) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName string

The insight name to be evaluated. 

const (
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameCharacterLength            TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "characterLength"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameClassImbalance             TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "classImbalance"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameExpectColumnAToBeInColumnB TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "expectColumnAToBeInColumnB"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameColumnAverage              TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "columnAverage"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameColumnDrift                TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "columnDrift"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameColumnValuesMatch          TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "columnValuesMatch"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameConfidenceDistribution     TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "confidenceDistribution"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameConflictingLabelRowCount   TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "conflictingLabelRowCount"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameContainsPii                TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "containsPii"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameContainsValidURL           TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "containsValidUrl"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameCorrelatedFeatures         TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "correlatedFeatures"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameCustomMetric               TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "customMetric"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameDuplicateRowCount          TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "duplicateRowCount"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameEmptyFeatures              TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "emptyFeatures"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameFeatureDrift               TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "featureDrift"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameFeatureProfile             TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "featureProfile"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameGreatExpectations          TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "greatExpectations"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameGroupByColumnStatsCheck    TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "groupByColumnStatsCheck"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameIllFormedRowCount          TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "illFormedRowCount"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameIsCode                     TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "isCode"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameIsJson                     TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "isJson"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameLlmRubricV2                TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "llmRubricV2"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameLabelDrift                 TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "labelDrift"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameMetrics                    TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "metrics"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameNewCategories              TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "newCategories"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameNewLabels                  TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "newLabels"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameNullRowCount               TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "nullRowCount"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNamePpScore                    TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "ppScore"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameQuasiConstantFeatures      TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "quasiConstantFeatures"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameSentenceLength             TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "sentenceLength"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameSizeRatio                  TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "sizeRatio"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameSpecialCharacters          TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "specialCharacters"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameStringValidation           TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "stringValidation"
	TestListResultsResponseLastUnskippedResultGoalThresholdsInsightNameTrainValLeakageRowCount    TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName = "trainValLeakageRowCount"
)

func (TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultGoalThresholdsInsightName) IsKnown() bool

type TestListResultsResponseLastUnskippedResultGoalThresholdsInsightParameter added in v0.4.0 

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

func (*TestListResultsResponseLastUnskippedResultGoalThresholdsInsightParameter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultGoalThresholdsOperator added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalThresholdsOperator string

The operator to be used for the evaluation. 

const (
	TestListResultsResponseLastUnskippedResultGoalThresholdsOperatorIs              TestListResultsResponseLastUnskippedResultGoalThresholdsOperator = "is"
	TestListResultsResponseLastUnskippedResultGoalThresholdsOperatorGreater         TestListResultsResponseLastUnskippedResultGoalThresholdsOperator = ">"
	TestListResultsResponseLastUnskippedResultGoalThresholdsOperatorGreaterOrEquals TestListResultsResponseLastUnskippedResultGoalThresholdsOperator = ">="
	TestListResultsResponseLastUnskippedResultGoalThresholdsOperatorLess            TestListResultsResponseLastUnskippedResultGoalThresholdsOperator = "<"
	TestListResultsResponseLastUnskippedResultGoalThresholdsOperatorLessOrEquals    TestListResultsResponseLastUnskippedResultGoalThresholdsOperator = "<="
	TestListResultsResponseLastUnskippedResultGoalThresholdsOperatorNotEquals       TestListResultsResponseLastUnskippedResultGoalThresholdsOperator = "!="
)

func (TestListResultsResponseLastUnskippedResultGoalThresholdsOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultGoalThresholdsOperator) IsKnown() bool

type TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdMode added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdMode string

Whether to use automatic anomaly detection or manual thresholds 

const (
	TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdModeAutomatic TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdMode = "automatic"
	TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdModeManual    TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdMode = "manual"
)

func (TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdMode) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultGoalThresholdsThresholdMode) IsKnown() bool

type TestListResultsResponseLastUnskippedResultGoalThresholdsValueArray added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalThresholdsValueArray []string

func (TestListResultsResponseLastUnskippedResultGoalThresholdsValueArray) ImplementsTestListResultsResponseLastUnskippedResultGoalThresholdsValueUnion added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultGoalThresholdsValueArray) ImplementsTestListResultsResponseLastUnskippedResultGoalThresholdsValueUnion()

type TestListResultsResponseLastUnskippedResultGoalThresholdsValueUnion added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalThresholdsValueUnion interface {
	ImplementsTestListResultsResponseLastUnskippedResultGoalThresholdsValueUnion()
}

The value to be compared.

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

type TestListResultsResponseLastUnskippedResultGoalType added in v0.4.0 

type TestListResultsResponseLastUnskippedResultGoalType string

The test type. 

const (
	TestListResultsResponseLastUnskippedResultGoalTypeIntegrity   TestListResultsResponseLastUnskippedResultGoalType = "integrity"
	TestListResultsResponseLastUnskippedResultGoalTypeConsistency TestListResultsResponseLastUnskippedResultGoalType = "consistency"
	TestListResultsResponseLastUnskippedResultGoalTypePerformance TestListResultsResponseLastUnskippedResultGoalType = "performance"
)

func (TestListResultsResponseLastUnskippedResultGoalType) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultGoalType) IsKnown() bool

type TestListResultsResponseLastUnskippedResultRowsBody added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBody struct {
	ColumnFilters     []TestListResultsResponseLastUnskippedResultRowsBodyColumnFilter `json:"columnFilters" api:"nullable"`
	ExcludeRowIDList  []int64                                                          `json:"excludeRowIdList" api:"nullable"`
	NotSearchQueryAnd []string                                                         `json:"notSearchQueryAnd" api:"nullable"`
	NotSearchQueryOr  []string                                                         `json:"notSearchQueryOr" api:"nullable"`
	RowIDList         []int64                                                          `json:"rowIdList" api:"nullable"`
	SearchQueryAnd    []string                                                         `json:"searchQueryAnd" api:"nullable"`
	SearchQueryOr     []string                                                         `json:"searchQueryOr" api:"nullable"`
	JSON              testListResultsResponseLastUnskippedResultRowsBodyJSON           `json:"-"`
}

The body of the rows request.

func (*TestListResultsResponseLastUnskippedResultRowsBody) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFilter added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFilter struct {
	// The name of the column.
	Measurement string                                                                  `json:"measurement" api:"required"`
	Operator    TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator `json:"operator" api:"required"`
	// This field can have the runtime type of
	// [[]TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterValueUnion],
	// [float64],
	// [TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterValueUnion].
	Value interface{}                                                        `json:"value" api:"required"`
	JSON  testListResultsResponseLastUnskippedResultRowsBodyColumnFilterJSON `json:"-"`
	// contains filtered or unexported fields
}

func (TestListResultsResponseLastUnskippedResultRowsBodyColumnFilter) AsUnion added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultRowsBodyColumnFilter) AsUnion() TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersUnion

AsUnion returns a TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilter, TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilter, TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilter.

func (*TestListResultsResponseLastUnskippedResultRowsBodyColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilter added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilter struct {
	// The name of the column.
	Measurement string                                                                                     `json:"measurement" api:"required"`
	Operator    TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator `json:"operator" api:"required"`
	Value       float64                                                                                    `json:"value" api:"required,nullable"`
	JSON        testListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterJSON     `json:"-"`
}

func (*TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator string
const (
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperatorGreater         TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator = ">"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperatorGreaterOrEquals TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator = ">="
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperatorIs              TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator = "is"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperatorLess            TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator = "<"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperatorLessOrEquals    TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator = "<="
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperatorNotEquals       TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator = "!="
)

func (TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilterOperator) IsKnown() bool

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator string
const (
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorContainsNone    TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "contains_none"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorContainsAny     TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "contains_any"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorContainsAll     TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "contains_all"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorOneOf           TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "one_of"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorNoneOf          TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "none_of"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorGreater         TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = ">"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorGreaterOrEquals TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = ">="
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorIs              TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "is"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorLess            TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "<"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorLessOrEquals    TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "<="
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperatorNotEquals       TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator = "!="
)

func (TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersOperator) IsKnown() bool

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilter added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilter struct {
	// The name of the column.
	Measurement string                                                                                     `json:"measurement" api:"required"`
	Operator    TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator     `json:"operator" api:"required"`
	Value       []TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterValueUnion `json:"value" api:"required"`
	JSON        testListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterJSON         `json:"-"`
}

func (*TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator string
const (
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperatorContainsNone TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator = "contains_none"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperatorContainsAny  TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator = "contains_any"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperatorContainsAll  TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator = "contains_all"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperatorOneOf        TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator = "one_of"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperatorNoneOf       TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator = "none_of"
)

func (TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterOperator) IsKnown() bool

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterValueUnion added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterValueUnion interface {
	ImplementsTestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionFloat.

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilter added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilter struct {
	// The name of the column.
	Measurement string                                                                                      `json:"measurement" api:"required"`
	Operator    TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperator   `json:"operator" api:"required"`
	Value       TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterValueUnion `json:"value" api:"required"`
	JSON        testListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterJSON       `json:"-"`
}

func (*TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilter) UnmarshalJSON added in v0.4.0 

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

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperator added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperator string
const (
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperatorIs        TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperator = "is"
	TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperatorNotEquals TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperator = "!="
)

func (TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterOperator) IsKnown() bool

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterValueUnion added in v0.4.0 

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterValueUnion interface {
	ImplementsTestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilterValueUnion()
}

Union satisfied by shared.UnionString or shared.UnionBool.

type TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersUnion added in v0.4.0 

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

Union satisfied by TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersSetColumnFilter, TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersNumericColumnFilter or TestListResultsResponseLastUnskippedResultRowsBodyColumnFiltersStringColumnFilter.

type TestListResultsResponseLastUnskippedResultStatus added in v0.4.0 

type TestListResultsResponseLastUnskippedResultStatus string

The status of the test. 

const (
	TestListResultsResponseLastUnskippedResultStatusRunning TestListResultsResponseLastUnskippedResultStatus = "running"
	TestListResultsResponseLastUnskippedResultStatusPassing TestListResultsResponseLastUnskippedResultStatus = "passing"
	TestListResultsResponseLastUnskippedResultStatusFailing TestListResultsResponseLastUnskippedResultStatus = "failing"
	TestListResultsResponseLastUnskippedResultStatusSkipped TestListResultsResponseLastUnskippedResultStatus = "skipped"
	TestListResultsResponseLastUnskippedResultStatusError   TestListResultsResponseLastUnskippedResultStatus = "error"
)

func (TestListResultsResponseLastUnskippedResultStatus) IsKnown added in v0.4.0 

func (r TestListResultsResponseLastUnskippedResultStatus) IsKnown() bool

type TestService added in v0.2.0 

type TestService struct {
	Options []option.RequestOption
}

TestService 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 NewTestService method instead.

func NewTestService added in v0.2.0 

func NewTestService(opts ...option.RequestOption) (r *TestService)

NewTestService 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 (*TestService) Evaluate added in v0.2.0 

func (r *TestService) Evaluate(ctx context.Context, testID string, body TestEvaluateParams, opts ...option.RequestOption) (res *TestEvaluateResponse, err error)

Triggers one-off evaluation of a specific monitoring test for a custom timestamp range. This allows evaluating tests for historical data or custom time periods outside the regular evaluation window schedule. It also allows overwriting the existing test results.

func (*TestService) ListResults added in v0.4.0 

func (r *TestService) ListResults(ctx context.Context, testID string, query TestListResultsParams, opts ...option.RequestOption) (res *TestListResultsResponse, err error)

List the test results for a test.

type WorkspaceAPIKeyNewParams added in v0.3.0 

type WorkspaceAPIKeyNewParams struct {
	// The API key name.
	Name param.Field[string] `json:"name"`
}

func (WorkspaceAPIKeyNewParams) MarshalJSON added in v0.3.0 

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

type WorkspaceAPIKeyNewResponse added in v0.3.0 

type WorkspaceAPIKeyNewResponse struct {
	// The API key id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The API key creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The API key last use date.
	DateLastUsed time.Time `json:"dateLastUsed" api:"required,nullable" format:"date-time"`
	// The API key last update date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The API key value.
	SecureKey string `json:"secureKey" api:"required"`
	// The API key name.
	Name string                         `json:"name" api:"nullable"`
	JSON workspaceAPIKeyNewResponseJSON `json:"-"`
}

func (*WorkspaceAPIKeyNewResponse) UnmarshalJSON added in v0.3.0 

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

type WorkspaceAPIKeyService added in v0.3.0 

type WorkspaceAPIKeyService struct {
	Options []option.RequestOption
}

WorkspaceAPIKeyService 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 NewWorkspaceAPIKeyService method instead.

func NewWorkspaceAPIKeyService added in v0.3.0 

func NewWorkspaceAPIKeyService(opts ...option.RequestOption) (r *WorkspaceAPIKeyService)

NewWorkspaceAPIKeyService 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 (*WorkspaceAPIKeyService) New added in v0.3.0 

func (r *WorkspaceAPIKeyService) New(ctx context.Context, workspaceID string, body WorkspaceAPIKeyNewParams, opts ...option.RequestOption) (res *WorkspaceAPIKeyNewResponse, err error)

Create a new API key in a workspace.

type WorkspaceGetResponse added in v0.3.0 

type WorkspaceGetResponse struct {
	// The workspace id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount" api:"required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount" api:"required"`
	// The workspace name.
	Name string `json:"name" api:"required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate" api:"required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate" api:"required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount" api:"required"`
	// The workspace slug.
	Slug         string                             `json:"slug" api:"required"`
	Status       WorkspaceGetResponseStatus         `json:"status" api:"required"`
	MonthlyUsage []WorkspaceGetResponseMonthlyUsage `json:"monthlyUsage"`
	// Whether the workspace only allows SAML authentication.
	SAMLOnlyAccess  bool                     `json:"samlOnlyAccess"`
	WildcardDomains []string                 `json:"wildcardDomains"`
	JSON            workspaceGetResponseJSON `json:"-"`
}

func (*WorkspaceGetResponse) UnmarshalJSON added in v0.3.0 

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

type WorkspaceGetResponseMonthlyUsage added in v0.3.0 

type WorkspaceGetResponseMonthlyUsage struct {
	ExecutionTimeMs int64                                `json:"executionTimeMs" api:"nullable"`
	MonthYear       time.Time                            `json:"monthYear" format:"date"`
	PredictionCount int64                                `json:"predictionCount"`
	JSON            workspaceGetResponseMonthlyUsageJSON `json:"-"`
}

func (*WorkspaceGetResponseMonthlyUsage) UnmarshalJSON added in v0.3.0 

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

type WorkspaceGetResponseStatus added in v0.3.0 

type WorkspaceGetResponseStatus string
const (
	WorkspaceGetResponseStatusActive            WorkspaceGetResponseStatus = "active"
	WorkspaceGetResponseStatusPastDue           WorkspaceGetResponseStatus = "past_due"
	WorkspaceGetResponseStatusUnpaid            WorkspaceGetResponseStatus = "unpaid"
	WorkspaceGetResponseStatusCanceled          WorkspaceGetResponseStatus = "canceled"
	WorkspaceGetResponseStatusIncomplete        WorkspaceGetResponseStatus = "incomplete"
	WorkspaceGetResponseStatusIncompleteExpired WorkspaceGetResponseStatus = "incomplete_expired"
	WorkspaceGetResponseStatusTrialing          WorkspaceGetResponseStatus = "trialing"
	WorkspaceGetResponseStatusPaused            WorkspaceGetResponseStatus = "paused"
)

func (WorkspaceGetResponseStatus) IsKnown added in v0.3.0 

func (r WorkspaceGetResponseStatus) IsKnown() bool

type WorkspaceInviteListParams added in v0.3.0 

type WorkspaceInviteListParams 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 (WorkspaceInviteListParams) URLQuery added in v0.3.0 

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

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

type WorkspaceInviteListResponse added in v0.3.0 

type WorkspaceInviteListResponse struct {
	Items []WorkspaceInviteListResponseItem `json:"items" api:"required"`
	JSON  workspaceInviteListResponseJSON   `json:"-"`
}

func (*WorkspaceInviteListResponse) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteListResponseItem added in v0.3.0 

type WorkspaceInviteListResponseItem struct {
	// The invite id.
	ID      string                                  `json:"id" api:"required" format:"uuid"`
	Creator WorkspaceInviteListResponseItemsCreator `json:"creator" api:"required"`
	// The invite creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The invite email.
	Email string `json:"email" api:"required" format:"email"`
	// The invite role.
	Role WorkspaceInviteListResponseItemsRole `json:"role" api:"required"`
	// The invite status.
	Status    WorkspaceInviteListResponseItemsStatus    `json:"status" api:"required"`
	Workspace WorkspaceInviteListResponseItemsWorkspace `json:"workspace" api:"required"`
	JSON      workspaceInviteListResponseItemJSON       `json:"-"`
}

func (*WorkspaceInviteListResponseItem) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteListResponseItemsCreator added in v0.3.0 

type WorkspaceInviteListResponseItemsCreator struct {
	// The invite creator id.
	ID string `json:"id" format:"uuid"`
	// The invite creator name.
	Name string `json:"name" api:"nullable"`
	// The invite creator username.
	Username string                                      `json:"username" api:"nullable"`
	JSON     workspaceInviteListResponseItemsCreatorJSON `json:"-"`
}

func (*WorkspaceInviteListResponseItemsCreator) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteListResponseItemsRole added in v0.3.0 

type WorkspaceInviteListResponseItemsRole string

The invite role. 

const (
	WorkspaceInviteListResponseItemsRoleAdmin  WorkspaceInviteListResponseItemsRole = "ADMIN"
	WorkspaceInviteListResponseItemsRoleMember WorkspaceInviteListResponseItemsRole = "MEMBER"
	WorkspaceInviteListResponseItemsRoleViewer WorkspaceInviteListResponseItemsRole = "VIEWER"
)

func (WorkspaceInviteListResponseItemsRole) IsKnown added in v0.3.0 

func (r WorkspaceInviteListResponseItemsRole) IsKnown() bool

type WorkspaceInviteListResponseItemsStatus added in v0.3.0 

type WorkspaceInviteListResponseItemsStatus string

The invite status. 

const (
	WorkspaceInviteListResponseItemsStatusAccepted WorkspaceInviteListResponseItemsStatus = "accepted"
	WorkspaceInviteListResponseItemsStatusPending  WorkspaceInviteListResponseItemsStatus = "pending"
)

func (WorkspaceInviteListResponseItemsStatus) IsKnown added in v0.3.0 

func (r WorkspaceInviteListResponseItemsStatus) IsKnown() bool

type WorkspaceInviteListResponseItemsWorkspace added in v0.3.0 

type WorkspaceInviteListResponseItemsWorkspace struct {
	ID          string                                        `json:"id" api:"required" format:"uuid"`
	DateCreated time.Time                                     `json:"dateCreated" api:"required" format:"date-time"`
	MemberCount int64                                         `json:"memberCount" api:"required"`
	Name        string                                        `json:"name" api:"required"`
	Slug        string                                        `json:"slug" api:"required"`
	JSON        workspaceInviteListResponseItemsWorkspaceJSON `json:"-"`
}

func (*WorkspaceInviteListResponseItemsWorkspace) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteNewParams added in v0.3.0 

type WorkspaceInviteNewParams struct {
	Emails param.Field[[]string] `json:"emails" format:"email"`
	// The member role.
	Role param.Field[WorkspaceInviteNewParamsRole] `json:"role"`
}

func (WorkspaceInviteNewParams) MarshalJSON added in v0.3.0 

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

type WorkspaceInviteNewParamsRole added in v0.3.0 

type WorkspaceInviteNewParamsRole string

The member role. 

const (
	WorkspaceInviteNewParamsRoleAdmin  WorkspaceInviteNewParamsRole = "ADMIN"
	WorkspaceInviteNewParamsRoleMember WorkspaceInviteNewParamsRole = "MEMBER"
	WorkspaceInviteNewParamsRoleViewer WorkspaceInviteNewParamsRole = "VIEWER"
)

func (WorkspaceInviteNewParamsRole) IsKnown added in v0.3.0 

func (r WorkspaceInviteNewParamsRole) IsKnown() bool

type WorkspaceInviteNewResponse added in v0.3.0 

type WorkspaceInviteNewResponse struct {
	Items []WorkspaceInviteNewResponseItem `json:"items" api:"required"`
	JSON  workspaceInviteNewResponseJSON   `json:"-"`
}

func (*WorkspaceInviteNewResponse) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteNewResponseItem added in v0.3.0 

type WorkspaceInviteNewResponseItem struct {
	// The invite id.
	ID      string                                 `json:"id" api:"required" format:"uuid"`
	Creator WorkspaceInviteNewResponseItemsCreator `json:"creator" api:"required"`
	// The invite creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The invite email.
	Email string `json:"email" api:"required" format:"email"`
	// The invite role.
	Role WorkspaceInviteNewResponseItemsRole `json:"role" api:"required"`
	// The invite status.
	Status    WorkspaceInviteNewResponseItemsStatus    `json:"status" api:"required"`
	Workspace WorkspaceInviteNewResponseItemsWorkspace `json:"workspace" api:"required"`
	JSON      workspaceInviteNewResponseItemJSON       `json:"-"`
}

func (*WorkspaceInviteNewResponseItem) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteNewResponseItemsCreator added in v0.3.0 

type WorkspaceInviteNewResponseItemsCreator struct {
	// The invite creator id.
	ID string `json:"id" format:"uuid"`
	// The invite creator name.
	Name string `json:"name" api:"nullable"`
	// The invite creator username.
	Username string                                     `json:"username" api:"nullable"`
	JSON     workspaceInviteNewResponseItemsCreatorJSON `json:"-"`
}

func (*WorkspaceInviteNewResponseItemsCreator) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteNewResponseItemsRole added in v0.3.0 

type WorkspaceInviteNewResponseItemsRole string

The invite role. 

const (
	WorkspaceInviteNewResponseItemsRoleAdmin  WorkspaceInviteNewResponseItemsRole = "ADMIN"
	WorkspaceInviteNewResponseItemsRoleMember WorkspaceInviteNewResponseItemsRole = "MEMBER"
	WorkspaceInviteNewResponseItemsRoleViewer WorkspaceInviteNewResponseItemsRole = "VIEWER"
)

func (WorkspaceInviteNewResponseItemsRole) IsKnown added in v0.3.0 

func (r WorkspaceInviteNewResponseItemsRole) IsKnown() bool

type WorkspaceInviteNewResponseItemsStatus added in v0.3.0 

type WorkspaceInviteNewResponseItemsStatus string

The invite status. 

const (
	WorkspaceInviteNewResponseItemsStatusAccepted WorkspaceInviteNewResponseItemsStatus = "accepted"
	WorkspaceInviteNewResponseItemsStatusPending  WorkspaceInviteNewResponseItemsStatus = "pending"
)

func (WorkspaceInviteNewResponseItemsStatus) IsKnown added in v0.3.0 

func (r WorkspaceInviteNewResponseItemsStatus) IsKnown() bool

type WorkspaceInviteNewResponseItemsWorkspace added in v0.3.0 

type WorkspaceInviteNewResponseItemsWorkspace struct {
	ID          string                                       `json:"id" api:"required" format:"uuid"`
	DateCreated time.Time                                    `json:"dateCreated" api:"required" format:"date-time"`
	MemberCount int64                                        `json:"memberCount" api:"required"`
	Name        string                                       `json:"name" api:"required"`
	Slug        string                                       `json:"slug" api:"required"`
	JSON        workspaceInviteNewResponseItemsWorkspaceJSON `json:"-"`
}

func (*WorkspaceInviteNewResponseItemsWorkspace) UnmarshalJSON added in v0.3.0 

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

type WorkspaceInviteService added in v0.3.0 

type WorkspaceInviteService struct {
	Options []option.RequestOption
}

WorkspaceInviteService 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 NewWorkspaceInviteService method instead.

func NewWorkspaceInviteService added in v0.3.0 

func NewWorkspaceInviteService(opts ...option.RequestOption) (r *WorkspaceInviteService)

NewWorkspaceInviteService 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 (*WorkspaceInviteService) List added in v0.3.0 

func (r *WorkspaceInviteService) List(ctx context.Context, workspaceID string, query WorkspaceInviteListParams, opts ...option.RequestOption) (res *WorkspaceInviteListResponse, err error)

Retrieve a list of invites in a workspace.

func (*WorkspaceInviteService) New added in v0.3.0 

func (r *WorkspaceInviteService) New(ctx context.Context, workspaceID string, body WorkspaceInviteNewParams, opts ...option.RequestOption) (res *WorkspaceInviteNewResponse, err error)

Invite users to a workspace.

type WorkspaceService added in v0.3.0 

type WorkspaceService struct {
	Options []option.RequestOption
	Invites *WorkspaceInviteService
	APIKeys *WorkspaceAPIKeyService
}

WorkspaceService 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 NewWorkspaceService method instead.

func NewWorkspaceService added in v0.3.0 

func NewWorkspaceService(opts ...option.RequestOption) (r *WorkspaceService)

NewWorkspaceService 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 (*WorkspaceService) Get added in v0.3.0 

func (r *WorkspaceService) Get(ctx context.Context, workspaceID string, opts ...option.RequestOption) (res *WorkspaceGetResponse, err error)

Retrieve a workspace by its ID.

func (*WorkspaceService) Update added in v0.3.0 

func (r *WorkspaceService) Update(ctx context.Context, workspaceID string, body WorkspaceUpdateParams, opts ...option.RequestOption) (res *WorkspaceUpdateResponse, err error)

Update a workspace.

type WorkspaceUpdateParams added in v0.3.0 

type WorkspaceUpdateParams struct {
	// The workspace invite code.
	InviteCode param.Field[string] `json:"inviteCode"`
	// The workspace name.
	Name param.Field[string] `json:"name"`
	// The workspace slug.
	Slug param.Field[string] `json:"slug"`
}

func (WorkspaceUpdateParams) MarshalJSON added in v0.3.0 

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

type WorkspaceUpdateResponse added in v0.3.0 

type WorkspaceUpdateResponse struct {
	// The workspace id.
	ID string `json:"id" api:"required" format:"uuid"`
	// The workspace creator id.
	CreatorID string `json:"creatorId" api:"required,nullable" format:"uuid"`
	// The workspace creation date.
	DateCreated time.Time `json:"dateCreated" api:"required" format:"date-time"`
	// The workspace last updated date.
	DateUpdated time.Time `json:"dateUpdated" api:"required" format:"date-time"`
	// The number of invites in the workspace.
	InviteCount int64 `json:"inviteCount" api:"required"`
	// The number of members in the workspace.
	MemberCount int64 `json:"memberCount" api:"required"`
	// The workspace name.
	Name string `json:"name" api:"required"`
	// The end date of the current billing period.
	PeriodEndDate time.Time `json:"periodEndDate" api:"required,nullable" format:"date-time"`
	// The start date of the current billing period.
	PeriodStartDate time.Time `json:"periodStartDate" api:"required,nullable" format:"date-time"`
	// The number of projects in the workspace.
	ProjectCount int64 `json:"projectCount" api:"required"`
	// The workspace slug.
	Slug         string                                `json:"slug" api:"required"`
	Status       WorkspaceUpdateResponseStatus         `json:"status" api:"required"`
	MonthlyUsage []WorkspaceUpdateResponseMonthlyUsage `json:"monthlyUsage"`
	// Whether the workspace only allows SAML authentication.
	SAMLOnlyAccess  bool                        `json:"samlOnlyAccess"`
	WildcardDomains []string                    `json:"wildcardDomains"`
	JSON            workspaceUpdateResponseJSON `json:"-"`
}

func (*WorkspaceUpdateResponse) UnmarshalJSON added in v0.3.0 

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

type WorkspaceUpdateResponseMonthlyUsage added in v0.3.0 

type WorkspaceUpdateResponseMonthlyUsage struct {
	ExecutionTimeMs int64                                   `json:"executionTimeMs" api:"nullable"`
	MonthYear       time.Time                               `json:"monthYear" format:"date"`
	PredictionCount int64                                   `json:"predictionCount"`
	JSON            workspaceUpdateResponseMonthlyUsageJSON `json:"-"`
}

func (*WorkspaceUpdateResponseMonthlyUsage) UnmarshalJSON added in v0.3.0 

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

type WorkspaceUpdateResponseStatus added in v0.3.0 

type WorkspaceUpdateResponseStatus string
const (
	WorkspaceUpdateResponseStatusActive            WorkspaceUpdateResponseStatus = "active"
	WorkspaceUpdateResponseStatusPastDue           WorkspaceUpdateResponseStatus = "past_due"
	WorkspaceUpdateResponseStatusUnpaid            WorkspaceUpdateResponseStatus = "unpaid"
	WorkspaceUpdateResponseStatusCanceled          WorkspaceUpdateResponseStatus = "canceled"
	WorkspaceUpdateResponseStatusIncomplete        WorkspaceUpdateResponseStatus = "incomplete"
	WorkspaceUpdateResponseStatusIncompleteExpired WorkspaceUpdateResponseStatus = "incomplete_expired"
	WorkspaceUpdateResponseStatusTrialing          WorkspaceUpdateResponseStatus = "trialing"
	WorkspaceUpdateResponseStatusPaused            WorkspaceUpdateResponseStatus = "paused"
)

func (WorkspaceUpdateResponseStatus) IsKnown added in v0.3.0 

func (r WorkspaceUpdateResponseStatus) IsKnown() bool

Source Files

View all Source files

Directories

Path Synopsis
apierror
apiform
apijson
apiquery
param
requestconfig
testutil

Jump to

Keyboard shortcuts

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