braintrust

type ACL = shared.ACL

type ACLListParams struct {
	// The id of the object the ACL applies to
	ObjectID param.Field[string] `query:"object_id,required" format:"uuid"`
	// The object type that the ACL applies to
	ObjectType param.Field[ACLListParamsObjectType] `query:"object_type,required"`
	// Pagination cursor id.
	//
	// For example, if the initial item in the last page you fetched had an id of
	// `foo`, pass `ending_before=foo` to fetch the previous page. Note: you may only
	// pass one of `starting_after` and `ending_before`
	EndingBefore param.Field[string] `query:"ending_before" format:"uuid"`
	// Filter search results to a particular set of object IDs. To specify a list of
	// IDs, include the query param multiple times
	IDs param.Field[ACLListParamsIDsUnion] `query:"ids" format:"uuid"`
	// Limit the number of objects to return
	Limit param.Field[int64] `query:"limit"`
	// Pagination cursor id.
	//
	// For example, if the final item in the last page you fetched had an id of `foo`,
	// pass `starting_after=foo` to fetch the next page. Note: you may only pass one of
	// `starting_after` and `ending_before`
	StartingAfter param.Field[string] `query:"starting_after" format:"uuid"`
}

type ACLListParamsIDsArray []string

type ACLListParamsIDsUnion interface {
	ImplementsACLListParamsIDsUnion()
}

type ACLListParamsObjectType string

type ACLNewParams struct {
	// An ACL grants a certain permission or role to a certain user or group on an
	// object.
	//
	// ACLs are inherited across the object hierarchy. So for example, if a user has
	// read permissions on a project, they will also have read permissions on any
	// experiment, dataset, etc. created within that project.
	//
	// To restrict a grant to a particular sub-object, you may specify
	// `restrict_object_type` in the ACL, as part of a direct permission grant or as
	// part of a role.
	CreateACL shared.CreateACLParam `json:"create_acl,required"`
}

type ACLObjectType = shared.ACLObjectType

type ACLPermission = shared.ACLPermission

type ACLRestrictObjectType = shared.ACLRestrictObjectType

type ACLService struct {
	Options []option.RequestOption
}

type APIKey = shared.APIKey

type APIKeyListParams struct {
	// Name of the api_key to search for
	APIKeyName param.Field[string] `query:"api_key_name"`
	// Pagination cursor id.
	//
	// For example, if the initial item in the last page you fetched had an id of
	// `foo`, pass `ending_before=foo` to fetch the previous page. Note: you may only
	// pass one of `starting_after` and `ending_before`
	EndingBefore param.Field[string] `query:"ending_before" format:"uuid"`
	// Filter search results to a particular set of object IDs. To specify a list of
	// IDs, include the query param multiple times
	IDs param.Field[APIKeyListParamsIDsUnion] `query:"ids" format:"uuid"`
	// Limit the number of objects to return
	Limit param.Field[int64] `query:"limit"`
	// Filter search results to within a particular organization
	OrgName param.Field[string] `query:"org_name"`
	// Pagination cursor id.
	//
	// For example, if the final item in the last page you fetched had an id of `foo`,
	// pass `starting_after=foo` to fetch the next page. Note: you may only pass one of
	// `starting_after` and `ending_before`
	StartingAfter param.Field[string] `query:"starting_after" format:"uuid"`
}

type APIKeyListParamsIDsArray []string

type APIKeyListParamsIDsUnion interface {
	ImplementsAPIKeyListParamsIDsUnion()
}

type APIKeyNewParams struct {
	// Name of the api key. Does not have to be unique
	Name param.Field[string] `json:"name,required"`
	// For nearly all users, this parameter should be unnecessary. But in the rare case
	// that your API key belongs to multiple organizations, you may specify the name of
	// the organization the API key belongs in.
	OrgName param.Field[string] `json:"org_name"`
}

type APIKeyService struct {
	Options []option.RequestOption
}

type Client struct {
	Options       []option.RequestOption
	TopLevel      *TopLevelService
	Projects      *ProjectService
	Experiments   *ExperimentService
	Datasets      *DatasetService
	Prompts       *PromptService
	Roles         *RoleService
	Groups        *GroupService
	ACLs          *ACLService
	Users         *UserService
	ProjectScores *ProjectScoreService
	ProjectTags   *ProjectTagService
	Functions     *FunctionService
	Views         *ViewService
	Organizations *OrganizationService
	APIKeys       *APIKeyService
}

type CreateACLObjectType = shared.CreateACLObjectType

type CreateACLParam = shared.CreateACLParam

type CreateACLPermission = shared.CreateACLPermission

type CreateACLRestrictObjectType = shared.CreateACLRestrictObjectType

type CreateAPIKeyOutput = shared.CreateAPIKeyOutput

type CreateDatasetParam = shared.CreateDatasetParam

type CreateExperimentParam = shared.CreateExperimentParam

type CreateFunctionFunctionDataCodeDataLocationParam = shared.CreateFunctionFunctionDataCodeDataLocationParam

type CreateFunctionFunctionDataCodeDataLocationPositionScoreParam = shared.CreateFunctionFunctionDataCodeDataLocationPositionScoreParam

type CreateFunctionFunctionDataCodeDataLocationPositionTask = shared.CreateFunctionFunctionDataCodeDataLocationPositionTask

type CreateFunctionFunctionDataCodeDataLocationPositionUnionParam = shared.CreateFunctionFunctionDataCodeDataLocationPositionUnionParam

type CreateFunctionFunctionDataCodeDataLocationType = shared.CreateFunctionFunctionDataCodeDataLocationType

type CreateFunctionFunctionDataCodeDataParam = shared.CreateFunctionFunctionDataCodeDataParam

type CreateFunctionFunctionDataCodeDataRuntimeContextParam = shared.CreateFunctionFunctionDataCodeDataRuntimeContextParam

type CreateFunctionFunctionDataCodeDataRuntimeContextRuntime = shared.CreateFunctionFunctionDataCodeDataRuntimeContextRuntime

type CreateFunctionFunctionDataCodeParam = shared.CreateFunctionFunctionDataCodeParam

type CreateFunctionFunctionDataCodeType = shared.CreateFunctionFunctionDataCodeType

type CreateFunctionFunctionDataGlobalParam = shared.CreateFunctionFunctionDataGlobalParam

type CreateFunctionFunctionDataGlobalType = shared.CreateFunctionFunctionDataGlobalType

type CreateFunctionFunctionDataPromptParam = shared.CreateFunctionFunctionDataPromptParam

type CreateFunctionFunctionDataPromptType = shared.CreateFunctionFunctionDataPromptType

type CreateFunctionFunctionDataType = shared.CreateFunctionFunctionDataType

type CreateFunctionFunctionDataUnionParam = shared.CreateFunctionFunctionDataUnionParam

type CreateFunctionParam = shared.CreateFunctionParam

type CreateGroupParam = shared.CreateGroupParam

type CreateProjectParam = shared.CreateProjectParam

type CreateProjectScoreCategoriesCategoricalParam = shared.CreateProjectScoreCategoriesCategoricalParam

type CreateProjectScoreCategoriesMinimumParam = shared.CreateProjectScoreCategoriesMinimumParam

type CreateProjectScoreCategoriesNullableVariantParam = shared.CreateProjectScoreCategoriesNullableVariantParam

type CreateProjectScoreCategoriesUnionParam = shared.CreateProjectScoreCategoriesUnionParam

type CreateProjectScoreParam = shared.CreateProjectScoreParam

type CreateProjectScoreScoreType = shared.CreateProjectScoreScoreType

type CreateProjectTagParam = shared.CreateProjectTagParam

type CreatePromptParam = shared.CreatePromptParam

type CreateRoleMemberPermissionParam = shared.CreateRoleMemberPermissionParam

type CreateRoleMemberPermissionsPermission = shared.CreateRoleMemberPermissionsPermission

type CreateRoleMemberPermissionsRestrictObjectType = shared.CreateRoleMemberPermissionsRestrictObjectType

type CreateRoleParam = shared.CreateRoleParam

type CreateViewObjectType = shared.CreateViewObjectType

type CreateViewParam = shared.CreateViewParam

type CreateViewViewType = shared.CreateViewViewType

type DataSummary = shared.DataSummary

type Dataset = shared.Dataset

type DatasetEvent = shared.DatasetEvent

type DatasetFeedbackParams struct {
	FeedbackDatasetEventRequest shared.FeedbackDatasetEventRequestParam `json:"feedback_dataset_event_request,required"`
}

type DatasetFetchParams struct {
	// limit the number of traces fetched
	//
	// Fetch queries may be paginated if the total result size is expected to be large
	// (e.g. project_logs which accumulate over a long time). Note that fetch queries
	// only support pagination in descending time order (from latest to earliest
	// `_xact_id`. Furthermore, later pages may return rows which showed up in earlier
	// pages, except with an earlier `_xact_id`. This happens because pagination occurs
	// over the whole version history of the event log. You will most likely want to
	// exclude any such duplicate, outdated rows (by `id`) from your combined result
	// set.
	//
	// The `limit` parameter controls the number of full traces to return. So you may
	// end up with more individual rows than the specified limit if you are fetching
	// events containing traces.
	Limit param.Field[int64] `query:"limit"`
	// DEPRECATION NOTICE: The manually-constructed pagination cursor is deprecated in
	// favor of the explicit 'cursor' returned by object fetch requests. Please prefer
	// the 'cursor' argument going forwards.
	//
	// Together, `max_xact_id` and `max_root_span_id` form a pagination cursor
	//
	// Since a paginated fetch query returns results in order from latest to earliest,
	// the cursor for the next page can be found as the row with the minimum (earliest)
	// value of the tuple `(_xact_id, root_span_id)`. See the documentation of `limit`
	// for an overview of paginating fetch queries.
	MaxRootSpanID param.Field[string] `query:"max_root_span_id"`
	// DEPRECATION NOTICE: The manually-constructed pagination cursor is deprecated in
	// favor of the explicit 'cursor' returned by object fetch requests. Please prefer
	// the 'cursor' argument going forwards.
	//
	// Together, `max_xact_id` and `max_root_span_id` form a pagination cursor
	//
	// Since a paginated fetch query returns results in order from latest to earliest,
	// the cursor for the next page can be found as the row with the minimum (earliest)
	// value of the tuple `(_xact_id, root_span_id)`. See the documentation of `limit`
	// for an overview of paginating fetch queries.
	MaxXactID param.Field[string] `query:"max_xact_id"`
	// Retrieve a snapshot of events from a past time
	//
	// The version id is essentially a filter on the latest event transaction id. You
	// can use the `max_xact_id` returned by a past fetch as the version to reproduce
	// that exact fetch.
	Version param.Field[string] `query:"version"`
}

type DatasetFetchPostParams struct {
	FetchEventsRequest shared.FetchEventsRequestParam `json:"fetch_events_request,required"`
}

type DatasetInsertParams struct {
	InsertDatasetEventRequest shared.InsertDatasetEventRequestParam `json:"insert_dataset_event_request,required"`
}

type DatasetListParams struct {
	// Name of the dataset to search for
	DatasetName param.Field[string] `query:"dataset_name"`
	// Pagination cursor id.
	//
	// For example, if the initial item in the last page you fetched had an id of
	// `foo`, pass `ending_before=foo` to fetch the previous page. Note: you may only
	// pass one of `starting_after` and `ending_before`
	EndingBefore param.Field[string] `query:"ending_before" format:"uuid"`
	// Filter search results to a particular set of object IDs. To specify a list of
	// IDs, include the query param multiple times
	IDs param.Field[DatasetListParamsIDsUnion] `query:"ids" format:"uuid"`
	// Limit the number of objects to return
	Limit param.Field[int64] `query:"limit"`
	// Filter search results to within a particular organization
	OrgName param.Field[string] `query:"org_name"`
	// Project id
	ProjectID param.Field[string] `query:"project_id" format:"uuid"`
	// Name of the project to search for
	ProjectName param.Field[string] `query:"project_name"`
	// Pagination cursor id.
	//
	// For example, if the final item in the last page you fetched had an id of `foo`,
	// pass `starting_after=foo` to fetch the next page. Note: you may only pass one of
	// `starting_after` and `ending_before`
	StartingAfter param.Field[string] `query:"starting_after" format:"uuid"`
}

type DatasetListParamsIDsArray []string

type DatasetListParamsIDsUnion interface {
	ImplementsDatasetListParamsIDsUnion()
}

type DatasetNewParams struct {
	CreateDataset shared.CreateDatasetParam `json:"create_dataset,required"`
}

type DatasetService struct {
	Options []option.RequestOption
}

type DatasetSummarizeParams struct {
	// Whether to summarize the data. If false (or omitted), only the metadata will be
	// returned.
	SummarizeData param.Field[bool] `query:"summarize_data"`
}

type DatasetUpdateParams struct {
	PatchDataset shared.PatchDatasetParam `json:"patch_dataset,required"`
}

type DeleteViewObjectType = shared.DeleteViewObjectType

type DeleteViewParam = shared.DeleteViewParam

type Error = apierror.Error

type Experiment = shared.Experiment

type ExperimentEvent = shared.ExperimentEvent

type ExperimentEventContext = shared.ExperimentEventContext

type ExperimentEventMetrics = shared.ExperimentEventMetrics

type ExperimentEventSpanAttributes = shared.ExperimentEventSpanAttributes

type ExperimentEventSpanAttributesType = shared.ExperimentEventSpanAttributesType

type ExperimentFeedbackParams struct {
	FeedbackExperimentEventRequest shared.FeedbackExperimentEventRequestParam `json:"feedback_experiment_event_request,required"`
}

type ExperimentFetchParams struct {
	// limit the number of traces fetched
	//
	// Fetch queries may be paginated if the total result size is expected to be large
	// (e.g. project_logs which accumulate over a long time). Note that fetch queries
	// only support pagination in descending time order (from latest to earliest
	// `_xact_id`. Furthermore, later pages may return rows which showed up in earlier
	// pages, except with an earlier `_xact_id`. This happens because pagination occurs
	// over the whole version history of the event log. You will most likely want to
	// exclude any such duplicate, outdated rows (by `id`) from your combined result
	// set.
	//
	// The `limit` parameter controls the number of full traces to return. So you may
	// end up with more individual rows than the specified limit if you are fetching
	// events containing traces.
	Limit param.Field[int64] `query:"limit"`
	// DEPRECATION NOTICE: The manually-constructed pagination cursor is deprecated in
	// favor of the explicit 'cursor' returned by object fetch requests. Please prefer
	// the 'cursor' argument going forwards.
	//
	// Together, `max_xact_id` and `max_root_span_id` form a pagination cursor
	//
	// Since a paginated fetch query returns results in order from latest to earliest,
	// the cursor for the next page can be found as the row with the minimum (earliest)
	// value of the tuple `(_xact_id, root_span_id)`. See the documentation of `limit`
	// for an overview of paginating fetch queries.
	MaxRootSpanID param.Field[string] `query:"max_root_span_id"`
	// DEPRECATION NOTICE: The manually-constructed pagination cursor is deprecated in
	// favor of the explicit 'cursor' returned by object fetch requests. Please prefer
	// the 'cursor' argument going forwards.
	//
	// Together, `max_xact_id` and `max_root_span_id` form a pagination cursor
	//
	// Since a paginated fetch query returns results in order from latest to earliest,
	// the cursor for the next page can be found as the row with the minimum (earliest)
	// value of the tuple `(_xact_id, root_span_id)`. See the documentation of `limit`
	// for an overview of paginating fetch queries.
	MaxXactID param.Field[string] `query:"max_xact_id"`
	// Retrieve a snapshot of events from a past time
	//
	// The version id is essentially a filter on the latest event transaction id. You
	// can use the `max_xact_id` returned by a past fetch as the version to reproduce
	// that exact fetch.
	Version param.Field[string] `query:"version"`
}

type ExperimentFetchPostParams struct {
	FetchEventsRequest shared.FetchEventsRequestParam `json:"fetch_events_request,required"`
}

type ExperimentInsertParams struct {
	InsertExperimentEventRequest shared.InsertExperimentEventRequestParam `json:"insert_experiment_event_request,required"`
}

type ExperimentListParams struct {
	// Pagination cursor id.
	//
	// For example, if the initial item in the last page you fetched had an id of
	// `foo`, pass `ending_before=foo` to fetch the previous page. Note: you may only
	// pass one of `starting_after` and `ending_before`
	EndingBefore param.Field[string] `query:"ending_before" format:"uuid"`
	// Name of the experiment to search for
	ExperimentName param.Field[string] `query:"experiment_name"`
	// Filter search results to a particular set of object IDs. To specify a list of
	// IDs, include the query param multiple times
	IDs param.Field[ExperimentListParamsIDsUnion] `query:"ids" format:"uuid"`
	// Limit the number of objects to return
	Limit param.Field[int64] `query:"limit"`
	// Filter search results to within a particular organization
	OrgName param.Field[string] `query:"org_name"`
	// Project id
	ProjectID param.Field[string] `query:"project_id" format:"uuid"`
	// Name of the project to search for
	ProjectName param.Field[string] `query:"project_name"`
	// Pagination cursor id.
	//
	// For example, if the final item in the last page you fetched had an id of `foo`,
	// pass `starting_after=foo` to fetch the next page. Note: you may only pass one of
	// `starting_after` and `ending_before`
	StartingAfter param.Field[string] `query:"starting_after" format:"uuid"`
}

type ExperimentListParamsIDsArray []string

type ExperimentListParamsIDsUnion interface {
	ImplementsExperimentListParamsIDsUnion()
}

type ExperimentNewParams struct {
	CreateExperiment shared.CreateExperimentParam `json:"create_experiment,required"`
}

type ExperimentService struct {
	Options []option.RequestOption
}

type ExperimentSummarizeParams struct {
	// The experiment to compare against, if summarizing scores and metrics. If
	// omitted, will fall back to the `base_exp_id` stored in the experiment metadata,
	// and then to the most recent experiment run in the same project. Must pass
	// `summarize_scores=true` for this id to be used
	ComparisonExperimentID param.Field[string] `query:"comparison_experiment_id" format:"uuid"`
	// Whether to summarize the scores and metrics. If false (or omitted), only the
	// metadata will be returned.
	SummarizeScores param.Field[bool] `query:"summarize_scores"`
}

type ExperimentUpdateParams struct {
	PatchExperiment shared.PatchExperimentParam `json:"patch_experiment,required"`
}

type FeedbackDatasetEventRequestParam = shared.FeedbackDatasetEventRequestParam

type FeedbackDatasetItemParam = shared.FeedbackDatasetItemParam

type FeedbackDatasetItemSource = shared.FeedbackDatasetItemSource

type FeedbackExperimentEventRequestParam = shared.FeedbackExperimentEventRequestParam

type FeedbackExperimentItemParam = shared.FeedbackExperimentItemParam

type FeedbackExperimentItemSource = shared.FeedbackExperimentItemSource

type FeedbackProjectLogsEventRequestParam = shared.FeedbackProjectLogsEventRequestParam

type FeedbackProjectLogsItemParam = shared.FeedbackProjectLogsItemParam

type FeedbackProjectLogsItemSource = shared.FeedbackProjectLogsItemSource

type FetchDatasetEventsResponse = shared.FetchDatasetEventsResponse

type FetchEventsRequestParam = shared.FetchEventsRequestParam

type FetchExperimentEventsResponse = shared.FetchExperimentEventsResponse

type FetchProjectLogsEventsResponse = shared.FetchProjectLogsEventsResponse

type Function = shared.Function

type FunctionFunctionData = shared.FunctionFunctionData

type FunctionFunctionDataCode = shared.FunctionFunctionDataCode

type FunctionFunctionDataCodeData = shared.FunctionFunctionDataCodeData

type FunctionFunctionDataCodeDataLocation = shared.FunctionFunctionDataCodeDataLocation

type FunctionFunctionDataCodeDataLocationPositionScore = shared.FunctionFunctionDataCodeDataLocationPositionScore

type FunctionFunctionDataCodeDataLocationPositionTask = shared.FunctionFunctionDataCodeDataLocationPositionTask

type FunctionFunctionDataCodeDataLocationPositionUnion = shared.FunctionFunctionDataCodeDataLocationPositionUnion

type FunctionFunctionDataCodeDataLocationType = shared.FunctionFunctionDataCodeDataLocationType

type FunctionFunctionDataCodeDataRuntimeContext = shared.FunctionFunctionDataCodeDataRuntimeContext

type FunctionFunctionDataCodeDataRuntimeContextRuntime = shared.FunctionFunctionDataCodeDataRuntimeContextRuntime

type FunctionFunctionDataCodeType = shared.FunctionFunctionDataCodeType

type FunctionFunctionDataGlobal = shared.FunctionFunctionDataGlobal

type FunctionFunctionDataGlobalType = shared.FunctionFunctionDataGlobalType

type FunctionFunctionDataPrompt = shared.FunctionFunctionDataPrompt

type FunctionFunctionDataPromptType = shared.FunctionFunctionDataPromptType

type FunctionFunctionDataType = shared.FunctionFunctionDataType

type FunctionListParams struct {
	// Pagination cursor id.
	//
	// For example, if the initial item in the last page you fetched had an id of
	// `foo`, pass `ending_before=foo` to fetch the previous page. Note: you may only
	// pass one of `starting_after` and `ending_before`
	EndingBefore param.Field[string] `query:"ending_before" format:"uuid"`
	// Name of the function to search for
	FunctionName param.Field[string] `query:"function_name"`
	// Filter search results to a particular set of object IDs. To specify a list of
	// IDs, include the query param multiple times
	IDs param.Field[FunctionListParamsIDsUnion] `query:"ids" format:"uuid"`
	// Limit the number of objects to return
	Limit param.Field[int64] `query:"limit"`
	// Filter search results to within a particular organization
	OrgName param.Field[string] `query:"org_name"`
	// Project id
	ProjectID param.Field[string] `query:"project_id" format:"uuid"`
	// Name of the project to search for
	ProjectName param.Field[string] `query:"project_name"`
	// Retrieve prompt with a specific slug
	Slug param.Field[string] `query:"slug"`
	// Pagination cursor id.
	//
	// For example, if the final item in the last page you fetched had an id of `foo`,
	// pass `starting_after=foo` to fetch the next page. Note: you may only pass one of
	// `starting_after` and `ending_before`
	StartingAfter param.Field[string] `query:"starting_after" format:"uuid"`
	// Retrieve prompt at a specific version.
	//
	// The version id can either be a transaction id (e.g. '1000192656880881099') or a
	// version identifier (e.g. '81cd05ee665fdfb3').
	Version param.Field[string] `query:"version"`
}

type FunctionListParamsIDsArray []string

type FunctionListParamsIDsUnion interface {
	ImplementsFunctionListParamsIDsUnion()
}

type FunctionLogID = shared.FunctionLogID

type FunctionNewParams struct {
	CreateFunction shared.CreateFunctionParam `json:"create_function,required"`
}

type FunctionReplaceParams struct {
	CreateFunction shared.CreateFunctionParam `json:"create_function,required"`
}

type FunctionService struct {
	Options []option.RequestOption
}

type FunctionUpdateParams struct {
	PatchFunction shared.PatchFunctionParam `json:"patch_function,required"`
}

type Group = shared.Group

type GroupListParams struct {
	// Pagination cursor id.
	//
	// For example, if the initial item in the last page you fetched had an id of
	// `foo`, pass `ending_before=foo` to fetch the previous page. Note: you may only
	// pass one of `starting_after` and `ending_before`
	EndingBefore param.Field[string] `query:"ending_before" format:"uuid"`
	// Name of the group to search for
	GroupName param.Field[string] `query:"group_name"`
	// Filter search results to a particular set of object IDs. To specify a list of
	// IDs, include the query param multiple times
	IDs param.Field[GroupListParamsIDsUnion] `query:"ids" format:"uuid"`
	// Limit the number of objects to return
	Limit param.Field[int64] `query:"limit"`
	// Filter search results to within a particular organization
	OrgName param.Field[string] `query:"org_name"`
	// Pagination cursor id.
	//
	// For example, if the final item in the last page you fetched had an id of `foo`,
	// pass `starting_after=foo` to fetch the next page. Note: you may only pass one of
	// `starting_after` and `ending_before`
	StartingAfter param.Field[string] `query:"starting_after" format:"uuid"`
}

type GroupListParamsIDsArray []string