new GalileoApiClient(): GalileoApiClient;

BaseClient.constructor;

protected client: undefined | Client<paths, `${string}/${string}`> = undefined;

BaseClient.client;

datasetId: string = "";

experimentId: string = "";

logStreamId: string = "";

projectId: string = "";

projectScoped: boolean = true;

projectType: "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect" = ProjectTypes.genAI;

runId: string = "";

optional sessionId: string = undefined;

protected token: string = '';

BaseClient.token;

static timestampRecord: number = 0;

get protected apiUrl(): string;

set protected apiUrl(url: string): void;

BaseClient.apiUrl;

appendRowsToDatasetContent(
   datasetId: string,
   etag: string,
rows: DatasetAppendRow[]): Promise<void>;

convertToCamelCase<T, TTarget>(obj: T): ValidatedCamelCase<T, TTarget>;

BaseClient.convertToCamelCase;

convertToSnakeCase<T, TTarget>(obj: T): ValidatedSnakeCase<T, TTarget>;

BaseClient.convertToSnakeCase;

countSessions(options: LogRecordsQueryCountRequest): Promise<LogRecordsQueryCountResponse>;

countSpans(options: LogRecordsQueryCountRequest): Promise<LogRecordsQueryCountResponse>;

countTraces(options: LogRecordsQueryCountRequest): Promise<LogRecordsQueryCountResponse>;

createCodeScorerVersion(
   scorerId: string,
   codeContent: string,
validationResult?: string): Promise<BaseScorerVersionResponse>;

createDataset(
   name: string,
   filePath: string,
format: DatasetFormat): Promise<any>;

createDataset(params: object): Promise<any>;

createExperiment(name: string, dataset?:
  | null
| ExperimentDatasetRequest): Promise<ExperimentResponseType>;

createGlobalPromptTemplate(
   template: object[],
   name: string,
options?: object): Promise<PromptTemplate>;

createJob(options: object): Promise<CreateJobResponse>;

createLlmScorerVersion(scorerId: string, options: object): Promise<BaseScorerVersionResponse>;

explanation;

rating;

createLlmScorerVersion(
   scorerId: string,
   instructions?: string,
   chainPollTemplate?: object,
   userPrompt?: string,
   cotEnabled?: boolean,
   modelName?: string,
numJudges?: number): Promise<BaseScorerVersionResponse>;

explanation;

rating;

createLogStream(name: string): Promise<LogStreamType>;

createLogStreamScorerSettings(logStreamId: string, scorers: ScorerConfig[]): Promise<void>;

createProject(name: string, options?: ProjectCreateOptions): Promise<{
  createdAt: string;
  createdBy?: null | string;
  id: string;
  name?: null | string;
  type?: null | "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect";
  updatedAt: string;
}>;

createPromptRunJob(
   experimentId: string,
   projectId: string,
   promptTemplateVersionId: string,
   datasetId: string,
   scorers?: ScorerConfig[],
promptSettings?: PromptRunSettings): Promise<CreateJobResponse>;

createPromptTemplate(template: object[], name: string): Promise<PromptTemplate>;

createRunScorerSettings(
   experimentId: string,
   projectId: string,
scorers: ScorerConfig[]): Promise<void>;

createScorer(options: createScorerOptions): Promise<ScorerResponse>;

createScorer(
   name: string,
   scorerType: ScorerTypes,
   description?: string,
   tags?: string[],
   defaults?: object,
   modelType?: "llm" | "code" | "slm",
   defaultVersionId?: string,
   scoreableNodeTypes?: (
  | "agent"
  | "llm"
  | "retriever"
  | "tool"
  | "workflow"
  | "control"
  | "trace"
  | "session")[],
   outputType?: OutputType,
inputType?: InputType): Promise<ScorerResponse>;

createSessionLegacy(__namedParameters: object): Promise<SessionCreateResponse>;

createUserProjectCollaborators(collaborators: object[], projectId?: string): Promise<object[]>;

deleteDataset(datasetId: string): Promise<void>;

deleteExperiment(id: string): Promise<void>;

deleteExperimentTag(experimentId: string, tagId: string): Promise<void>;

deleteGlobalPromptTemplate(id: string): Promise<void>;

deleteProject(projectId: string): Promise<{
  message: string;
}>;

deleteScorer(scorerId: string): Promise<DeleteScorerResponse>;

deleteSessions(options: LogRecordsDeleteRequest): Promise<LogRecordsDeleteResponse>;

deleteSpans(options: LogRecordsDeleteRequest): Promise<LogRecordsDeleteResponse>;

deleteTraces(options: LogRecordsDeleteRequest): Promise<LogRecordsDeleteResponse>;

deleteUserProjectCollaborator(userId: string, projectId: string): Promise<void>;

exportRecords(options: LogRecordsExportRequest): Promise<AsyncIterable<string | Record<string, unknown>, any, any>>;

extendDataset(params: SyntheticDatasetExtensionRequest): Promise<SyntheticDatasetExtensionResponse>;

getAggregatedTraceView(options: AggregatedTraceViewRequest): Promise<AggregatedTraceViewResponse>;

protected getApiUrl(projectType: string): string;

BaseClient.getApiUrl;

protected getAuthHeader(token: string): object;

Authorization: string;

BaseClient.getAuthHeader;

getDataset(id: string): Promise<DatasetDBType>;

getDatasetByName(name: string): Promise<DatasetDBType>;

getDatasetContent(datasetId: string): Promise<DatasetRow[]>;

getDatasetEtag(id: string): Promise<string>;

getDatasets(limit?: number): Promise<DatasetDBType[]>;

getDatasetVersionContent(datasetId: string, versionIndex: number): Promise<DatasetContent>;

getDatasetVersionHistory(datasetId: string): Promise<DatasetVersionHistory>;

getExperiment(id: string): Promise<ExperimentResponseType>;

getExperimentMetrics(
   id: string,
   projectId: string,
metricsRequest: ExperimentMetricsRequest): Promise<ExperimentMetricsResponse>;

getExperiments(): Promise<ExperimentResponseType[]>;

getExperimentsAvailableColumns(): Promise<ExperimentsAvailableColumnsResponse>;

getExperimentsPaginated(options?: object): Promise<ListExperimentResponse>;

getExperimentTags(experimentId: string): Promise<RunTagDB[]>;

getExtendDatasetStatus(datasetId: string): Promise<JobProgress>;

getGlobalProjectByName(name: string, projectType?: "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect"): Promise<{
  bookmark?: boolean;
  createdAt: string;
  createdBy: string;
  createdByUser: {
     email: string;
     firstName?: null | string;
     id: string;
     lastName?: null | string;
  };
  description?: null | string;
  id: string;
  labels?: "sample"[];
  name?: null | string;
  permissions?: object[];
  runs: object[];
  type?: null | "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect";
  updatedAt: string;
}>;

getGlobalPromptTemplate(id: string): Promise<PromptTemplate>;

getGlobalPromptTemplateVersion(id: string, version: number): Promise<PromptTemplateVersion>;

getJob(jobId: string): Promise<JobDbType>;

getJobsForProjectRun(projectId: string, runId: string): Promise<JobDbType[]>;

getLogStream(id: string): Promise<LogStreamType>;

getLogStreamByName(name: string): Promise<LogStreamType>;

getLogStreams(): Promise<LogStreamType[]>;

getProject(id: string): Promise<{
  bookmark?: boolean;
  createdAt: string;
  createdBy: string;
  createdByUser: {
     email: string;
     firstName?: null | string;
     id: string;
     lastName?: null | string;
  };
  description?: null | string;
  id: string;
  labels?: "sample"[];
  name?: null | string;
  permissions?: object[];
  runs: object[];
  type?: null | "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect";
  updatedAt: string;
}>;

getProjectByName(name: string, options?: object): Promise<{
  bookmark?: boolean;
  createdAt: string;
  createdBy: string;
  createdByUser: {
     email: string;
     firstName?: null | string;
     id: string;
     lastName?: null | string;
  };
  description?: null | string;
  id: string;
  labels?: "sample"[];
  name?: null | string;
  permissions?: object[];
  runs: object[];
  type?: null | "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect";
  updatedAt: string;
}>;

getProjectIdByName(name: string, projectType?: "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect"): Promise<string>;

getProjects(projectType?: "prompt_evaluation" | "llm_monitor" | "gen_ai" | "protect"): Promise<object[]>;

getPromptTemplate(id: string): Promise<PromptTemplate>;

getPromptTemplates(): Promise<PromptTemplate[]>;

getPromptTemplateVersion(id: string, version: number): Promise<PromptTemplateVersion>;

getPromptTemplateVersionByName(name: string, version?: number): Promise<PromptTemplateVersion>;

getRunScorerJobs(projectId: string, runId: string): Promise<JobDbType[]>;

getScorers(options?: object): Promise<ScorerResponse[]>;

getScorersPage(options?: object): Promise<ListScorersResponse>;

getScorersPageByIds(options: object): Promise<ListScorersResponse>;

getScorersPageByLabels(options: object): Promise<ListScorersResponse>;

getScorerVersion(scorerId: string, version: number): Promise<BaseScorerVersionResponse>;

getSession(sessionId: string): Promise<ExtendedSessionRecordWithChildren>;

getSessionsAvailableColumns(options: LogRecordsAvailableColumnsRequest): Promise<LogRecordsAvailableColumnsResponse>;

getSpan(spanId: string): Promise<ExtendedSpanRecord>;

getSpansAvailableColumns(options: LogRecordsAvailableColumnsRequest): Promise<LogRecordsAvailableColumnsResponse>;

getTrace(traceId: string): Promise<ExtendedTraceRecordWithChildren>;

getTracesAvailableColumns(options: LogRecordsAvailableColumnsRequest): Promise<LogRecordsAvailableColumnsResponse>;

protected healthCheck(): Promise<boolean>;

BaseClient.healthCheck;

ingestSpans(options: LogSpansIngestRequest): Promise<LogSpansIngestResponse>;

ingestTraces(options: LogTracesIngestRequest): Promise<LogTracesIngestResponse>;

ingestTracesLegacy(traces: Trace[]): Promise<void>;

init(params: Partial<GalileoApiClientParams>): Promise<void>;

protected initializeClient(): void;

BaseClient.initializeClient;

listDatasetProjects(datasetId: string, limit: number): Promise<ListDatasetProjectsResponse>;

listGlobalPromptTemplates(
   nameFilter: string,
   limit: number,
startingToken: number): Promise<ListPromptTemplateResponse>;

listGlobalPromptTemplates(options: GlobalPromptTemplateListOptions): Promise<ListPromptTemplateResponse>;