braintrust 0.0.56 → 0.0.58

package/dist/isomorph.d.ts

@@ -9,11 +9,23 @@ export interface RepoStatus {
     commit_message?: string;
     commit_time?: string;
 }
+export interface CallerLocation {
+    caller_functionname: string;
+    caller_filename: string;
+    caller_lineno: number;
+}
+export interface IsoAsyncLocalStorage<T> {
+    enterWith(store: T): void;
+    run<R>(store: T | undefined, callback: () => R): R;
+    getStore(): T | undefined;
+}
 export interface Common {
     makeAxios: (conf: CreateAxiosDefaults) => AxiosInstance;
     getRepoStatus: () => Promise<RepoStatus | undefined>;
     getPastNAncestors: () => Promise<string[]>;
     getEnv: (name: string) => string | undefined;
+    getCallerLocation: () => CallerLocation | undefined;
+    newAsyncLocalStorage: <T>() => IsoAsyncLocalStorage<T>;
 }
 declare const iso: Common;
 export default iso;

package/dist/logger.d.ts

@@ -1,18 +1,214 @@
+import { AxiosInstance } from "axios";
+import { IsoAsyncLocalStorage } from "./isomorph";
+import { IS_MERGE_FIELD } from "./util";
+export type SetCurrentArg = {
+    setCurrent?: boolean;
+};
+export type StartSpanArgs = {
+    spanAttributes?: Record<any, any>;
+    startTime?: number;
+    event?: ExperimentLogPartialArgs & Partial<IdField>;
+};
+export type StartSpanOptionalNameArgs = StartSpanArgs & {
+    name?: string;
+};
+export type EndSpanArgs = {
+    endTime?: number;
+};
+/**
+ * A Span encapsulates logged data and metrics for a unit of work. This interface is shared by all span implementations.
+ *
+ * We suggest using one of the various `startSpan` methods, instead of creating Spans directly. See `Span.startSpan` for full details.
+ */
+export interface Span {
+    /**
+     * Row ID of the span.
+     */
+    id: string;
+    /**
+     * Span ID of the span. This is used to link spans together.
+     */
+    span_id: string;
+    /**
+     * Span ID of the root span in the full trace.
+     */
+    root_span_id: string;
+    /**
+     * Incrementally update the current span with new data. The event will be batched and uploaded behind the scenes.
+     *
+     * @param event: Data to be logged. See `Experiment.log` for full details.
+     */
+    log(event: ExperimentLogPartialArgs): void;
+    /**
+     * Create a new span. This is useful if you want to log more detailed trace information beyond the scope of a single log event. Data logged over several calls to `Span.log` will be merged into one logical row.
+     *
+     * We recommend running spans within a callback (using `startSpanWithinCallback`) to automatically mark them as current and ensure they are terminated. If you wish to start a span outside a callback, be sure to terminate it with `span.end()`.
+     *
+     * @param name The name of the span.
+     * @param args.span_attributes Optional additional attributes to attach to the span, such as a type name.
+     * @param args.start_time Optional start time of the span, as a timestamp in seconds.
+     * @param args.event Data to be logged. See `Experiment.log` for full details.
+     * @returns The newly-created `Span`
+     */
+    startSpan(name: string, args?: StartSpanArgs): Span;
+    /**
+     * Wrapper over `Span.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.startSpan` for full details.
+     *
+     * @param args.setCurrent If true (the default), the span will be marked as the currently-active span for the duration of the callback. Equivalent to calling `braintrust.withCurrent(span, callback)`.
+     */
+    traced<R>(name: string, callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    /**
+     * Terminate the span. Returns the end time logged to the row's metrics. After calling end, you may not invoke any further methods on the span object, except for the property accessors.
+     *
+     * Will be invoked automatically if the span is constructed with traced.
+     *
+     * @param args.endTime Optional end time of the span, as a timestamp in seconds.
+     * @returns The end time logged to the span metrics.
+     */
+    end(args?: EndSpanArgs): number;
+    /**
+     * Alias for `end`.
+     */
+    close(args?: EndSpanArgs): number;
+    kind: "span";
+}
+/**
+ * A fake implementation of the Span API which does nothing. This can be used as the default span.
+ */
+export declare class NoopSpan implements Span {
+    id: string;
+    span_id: string;
+    root_span_id: string;
+    kind: "span";
+    constructor();
+    log(_: ExperimentLogPartialArgs): void;
+    startSpan(_0: string, _1?: StartSpanArgs): this;
+    traced<R>(_0: string, callback: (span: Span) => R, _1: StartSpanArgs & SetCurrentArg): R;
+    end(args?: EndSpanArgs): number;
+    close(args?: EndSpanArgs): number;
+}
+export declare const noopSpan: NoopSpan;
+declare global {
+    var __inherited_braintrust_state: BraintrustState;
+}
+declare class BraintrustState {
+    id: string;
+    currentExperiment: IsoAsyncLocalStorage<Experiment | undefined>;
+    currentSpan: IsoAsyncLocalStorage<Span>;
+    apiUrl: string | null;
+    loginToken: string | null;
+    orgId: string | null;
+    orgName: string | null;
+    logUrl: string | null;
+    loggedIn: boolean;
+    private _apiConn;
+    private _logConn;
+    private _userInfo;
+    constructor();
+    apiConn(): HTTPConnection;
+    logConn(): HTTPConnection;
+    userInfo(): Promise<UserInfo>;
+    setUserInfoIfNull(info: UserInfo): void;
+}
+export declare const _internalGetGlobalState: () => BraintrustState;
+declare class HTTPConnection {
+    base_url: string;
+    token: string | null;
+    session: AxiosInstance | null;
+    constructor(base_url: string);
+    ping(): Promise<boolean>;
+    make_long_lived(): void;
+    static sanitize_token(token: string): string;
+    set_token(token: string): void;
+    _reset(): void;
+    get(path: string, params?: unknown | undefined): Promise<import("axios").AxiosResponse<any, any>>;
+    post(path: string, params?: unknown | undefined, config?: any): Promise<import("axios").AxiosResponse<any, any>>;
+    get_json(object_type: string, args?: unknown | undefined, retries?: number): Promise<any>;
+    post_json(object_type: string, args?: unknown | undefined): Promise<any>;
+}
+interface UserInfo {
+    id: string;
+}
 export declare class Project {
     name: string;
     id: string;
     org_id: string;
     constructor(name: string, id: string, org_id: string);
 }
+export type IdField = {
+    id: string;
+};
+export type InputField = {
+    input: unknown;
+};
+export type InputsField = {
+    inputs: unknown;
+};
+export type OtherExperimentLogFields = {
+    output: unknown;
+    expected: unknown;
+    scores: Record<string, number>;
+    metadata: Record<string, unknown>;
+    metrics: Record<string, unknown>;
+    datasetRecordId: string;
+};
+export type ExperimentLogPartialArgs = Partial<OtherExperimentLogFields> & Partial<InputField | InputsField>;
+export type ExperimentLogFullArgs = Partial<Omit<OtherExperimentLogFields, "scores">> & Required<Pick<OtherExperimentLogFields, "scores">> & Partial<InputField | InputsField> & Partial<IdField>;
+type ExperimentEvent = Partial<InputField> & Partial<OtherExperimentLogFields> & {
+    id: string;
+    span_id: string;
+    root_span_id: string;
+    project_id: string;
+    experiment_id: string;
+    [IS_MERGE_FIELD]: boolean;
+} & Partial<{
+    user_id: string;
+    created: string;
+    span_parents: string[];
+    span_attributes: Record<string, unknown>;
+}>;
+interface DatasetEvent {
+    inputs?: unknown;
+    output?: unknown;
+    metadata?: unknown;
+    id: string;
+    project_id: string;
+    dataset_id: string;
+    user_id: string;
+    created: string;
+}
+type LogEvent = ExperimentEvent | DatasetEvent;
 export interface DatasetRecord {
     id: string;
     input: any;
     output: any;
     metadata: any;
 }
+declare class LogThread {
+    private items;
+    private active_flush;
+    private active_flush_resolved;
+    log(items: LogEvent[]): void;
+    flush_once(batchSize?: number): Promise<string[]>;
+    flush(): Promise<void>;
+}
+export type InitOptions = {
+    experiment?: string;
+    description?: string;
+    dataset?: Dataset;
+    update?: boolean;
+    baseExperiment?: string;
+    isPublic?: boolean;
+    apiUrl?: string;
+    apiKey?: string;
+    orgName?: string;
+    disableCache?: boolean;
+};
 /**
  * Log in, and then initialize a new experiment in a specified project. If the project does not exist, it will be created.
  *
+ * Remember to close your experiment when it is finished by calling `Experiment.close`. We recommend initializing the experiment within a callback (using `braintrust.withExperiment`) to automatically mark it as current and ensure it is terminated.
+ *
  * @param project The name of the project to create the experiment in.
  * @param options Additional options for configuring init().
  * @param options.experiment The name of the experiment to create. If not specified, a name will be generated automatically.
@@ -30,21 +226,27 @@ export interface DatasetRecord {
  * @param options.disableCache Do not use cached login information.
  * @returns The newly created Experiment.
  */
-export declare function init(project: string, options?: {
-    readonly experiment?: string;
-    readonly description?: string;
-    readonly dataset?: Dataset;
-    readonly update?: boolean;
-    readonly baseExperiment?: string;
-    readonly isPublic?: boolean;
-    readonly apiUrl?: string;
-    readonly apiKey?: string;
-    readonly orgName?: string;
-    readonly disableCache?: boolean;
-}): Promise<Experiment>;
+export declare function init(project: string, options?: Readonly<InitOptions>): Promise<Experiment>;
+/**
+ * Wrapper over `braintrust.init`, which passes the initialized `Experiment` it to the given callback and closes it afterwards. See `braintrust.init` for full details.
+ *
+ * @param options.setCurrent If true (default), set the currently-active experiment to the newly-created one. Equivalent to calling `braintrust.withCurrent(experiment, callback)`.
+ */
+export declare function withExperiment<R>(project: string, callback: (experiment: Experiment) => R, options?: Readonly<InitOptions & SetCurrentArg>): Promise<R>;
+type InitDatasetOptions = {
+    dataset?: string;
+    description?: string;
+    version?: string;
+    apiUrl?: string;
+    apiKey?: string;
+    orgName?: string;
+    disableCache?: boolean;
+};
 /**
  * Create a new dataset in a specified project. If the project does not exist, it will be created.
  *
+ * Remember to close your dataset when it is finished by calling `Dataset.close`. We recommend initializing the dataset within a callback (using `braintrust.withDataset`) to ensure it is terminated.
+ *
  * @param project The name of the project to create the dataset in.
  * @param options Additional options for configuring init().
  * @param options.dataset The name of the dataset to create. If not specified, a name will be generated automatically.
@@ -56,15 +258,11 @@ export declare function init(project: string, options?: {
  * @param options.disableCache Do not use cached login information.
  * @returns The newly created Dataset.
  */
-export declare function initDataset(project: string, options?: {
-    readonly dataset?: string;
-    readonly description?: string;
-    readonly version?: string;
-    readonly apiUrl?: string;
-    readonly apiKey?: string;
-    readonly orgName?: string;
-    readonly disableCache?: boolean;
-}): Promise<Dataset>;
+export declare function initDataset(project: string, options?: Readonly<InitDatasetOptions>): Promise<Dataset>;
+/**
+ * Wrapper over `braintrust.initDataset`, which passes the initialized `Dataset` it to the given callback and closes it afterwards. See `braintrust.initDataset` for full details.
+ */
+export declare function withDataset<R>(project: string, callback: (dataset: Dataset) => R, options?: Readonly<InitDatasetOptions>): Promise<R>;
 /**
  * Log into Braintrust. This will prompt you for your API token, which you can find at
  * https://www.braintrustdata.com/app/token. This method is called automatically by `init()`.
@@ -87,42 +285,10 @@ export declare function login(options?: {
 /**
  * Log a single event to the current experiment. The event will be batched and uploaded behind the scenes.
  *
- * @param event The event to log.
- * @param event.input The arguments that uniquely define a test case (an arbitrary, JSON serializable object). Later on,
- * Braintrust will use the `input` to know whether two test cases are the same between experiments, so they should
- * not contain experiment-specific state. A simple rule of thumb is that if you run the same experiment twice, the
- * `input` should be identical.
- * @param event.output The output of your application, including post-processing (an arbitrary, JSON serializable object),
- * that allows you to determine whether the result is correct or not. For example, in an app that generates SQL queries,
- * the `output` should be the _result_ of the SQL query generated by the model, not the query itself, because there may
- * be multiple valid queries that answer a single question.
- * @param event.expected The ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to
- * determine if your `output` value is correct or not. Braintrust currently does not compare `output` to `expected` for
- * you, since there are so many different ways to do that correctly. Instead, these values are just used to help you
- * navigate your experiments while digging into analyses. However, we may later use these values to re-score outputs or
- * fine-tune your models.
- * @param event.scores A dictionary of numeric values (between 0 and 1) to log. The scores should give you a variety of signals
- * that help you determine how accurate the outputs are compared to what you expect and diagnose failures. For example, a
- * summarization app might have one score that tells you how accurate the summary is, and another that measures the word similarity
- * between the generated and grouth truth summary. The word similarity score could help you determine whether the summarization was
- * covering similar concepts or not. You can use these scores to help you sort, filter, and compare experiments.
- * @param event.metadata (Optional) a dictionary with additional data about the test example, model outputs, or just
- * about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the
- * `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any
- * JSON-serializable type, but its keys must be strings.
- * @param event.id (Optional) a unique identifier for the event. If you don't provide one, Braintrust will generate one for you.
- * @param event.inputs (Deprecated) the same as `input` (will be removed in a future version)
+ * @param event The event to log. See `Experiment.log` for full details.
  * @returns The `id` of the logged event.
  */
-export declare function log(options: {
-    readonly input?: unknown;
-    readonly output: unknown;
-    readonly expected?: unknown;
-    readonly scores: Record<string, number>;
-    readonly metadata?: Record<string, unknown>;
-    readonly id?: string;
-    readonly inputs?: unknown;
-}): string;
+export declare function log(event: ExperimentLogFullArgs): string;
 /**
  * Summarize the current experiment, including the scores (compared to the closest reference experiment) and metadata.
  *
@@ -135,6 +301,37 @@ export declare function summarize(options?: {
     readonly summarizeScores?: boolean;
     readonly comparisonExperimentId?: string;
 }): Promise<ExperimentSummary>;
+/**
+ * Returns the currently-active experiment (set by `braintrust.withExperiment` or `braintrust.withCurrent`). Returns undefined if no current experiment has been set.
+ */
+export declare function currentExperiment(): Experiment | undefined;
+/**
+ * Return the currently-active span for logging (set by `traced` or `braintrust.withCurrent`). If there is no active span, returns a no-op span object, which supports the same interface as spans but does no logging.
+ *
+ * See `Span` for full details.
+ */
+export declare function currentSpan(): Span;
+/**
+ * Toplevel function for starting a span. If there is a currently-active span, the new span is created as a subspan. Otherwise, if there is a currently-active experiment, the new span is created as a toplevel span. Otherwise, it returns a no-op span object.
+ *
+ * Unless a name is explicitly provided, the name of the span will be the name of the calling function, or "root" if no meaningful name can be determined.
+ *
+ * We recommend running spans within a callback (using `startSpanWithinCallback`) to automatically mark them as current and ensure they are terminated. If you wish to start a span outside a callback, be sure to terminate it with `span.end()`.
+ *
+ * See `Span.startSpan` for full details.
+ */
+export declare function startSpan(args?: StartSpanOptionalNameArgs): Span;
+/**
+ * Wrapper over `braintrust.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.traced` for full details.
+ */
+export declare function traced<R>(callback: (span: Span) => R, args?: StartSpanOptionalNameArgs & SetCurrentArg): R;
+/**
+ * Set the given experiment or span as current within the given callback and any asynchronous operations created within the callback. The current experiment can be accessed with `braintrust.currentExperiment`, and the current span with `braintrust.currentSpan`.
+ *
+ * @param object: The experiment or span to be marked as current.
+ * @param callback: The callback to be run under the scope of the current object.
+ */
+export declare function withCurrent<R>(object: Experiment | Span, callback: () => R): R;
 /**
  * An experiment is a collection of logged events, such as model inputs and outputs, which represent
  * a snapshot of your application at a particular point in time. An experiment is meant to capture more
@@ -154,47 +351,36 @@ export declare class Experiment {
     readonly user_id: string;
     readonly dataset?: Dataset;
     private logger;
+    private lastStartTime;
+    private finished;
+    kind: "experiment";
     constructor(project: Project, id: string, name: string, user_id: string, dataset?: Dataset);
     /**
      * Log a single event to the experiment. The event will be batched and uploaded behind the scenes.
      *
      * @param event The event to log.
-     * @param event.input The arguments that uniquely define a test case (an arbitrary, JSON serializable object). Later on,
-     * Braintrust will use the `input` to know whether two test cases are the same between experiments, so they should
-     * not contain experiment-specific state. A simple rule of thumb is that if you run the same experiment twice, the
-     * `input` should be identical.
-     * @param event.output The output of your application, including post-processing (an arbitrary, JSON serializable object),
-     * that allows you to determine whether the result is correct or not. For example, in an app that generates SQL queries,
-     * the `output` should be the _result_ of the SQL query generated by the model, not the query itself, because there may
-     * be multiple valid queries that answer a single question.
-     * @param event.expected The ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to
-     * determine if your `output` value is correct or not. Braintrust currently does not compare `output` to `expected` for
-     * you, since there are so many different ways to do that correctly. Instead, these values are just used to help you
-     * navigate your experiments while digging into analyses. However, we may later use these values to re-score outputs or
-     * fine-tune your models.
-     * @param event.scores A dictionary of numeric values (between 0 and 1) to log. The scores should give you a variety of signals
-     * that help you determine how accurate the outputs are compared to what you expect and diagnose failures. For example, a
-     * summarization app might have one score that tells you how accurate the summary is, and another that measures the word similarity
-     * between the generated and grouth truth summary. The word similarity score could help you determine whether the summarization was
-     * covering similar concepts or not. You can use these scores to help you sort, filter, and compare experiments.
-     * @param event.metadata (Optional) a dictionary with additional data about the test example, model outputs, or just
-     * about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the
-     * `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any
-     * JSON-serializable type, but its keys must be strings.
-     * @param event.id (Optional) a unique identifier for the event. If you don't provide one, Braintrust will generate one for you.
-     * @param event.inputs (Deprecated) the same as `input` (will be removed in a future version)
-     * @returns The `id` of the logged event.
+     * @param event.input: The arguments that uniquely define a test case (an arbitrary, JSON serializable object). Later on, Braintrust will use the `input` to know whether two test cases are the same between experiments, so they should not contain experiment-specific state. A simple rule of thumb is that if you run the same experiment twice, the `input` should be identical.
+     * @param event.output: The output of your application, including post-processing (an arbitrary, JSON serializable object), that allows you to determine whether the result is correct or not. For example, in an app that generates SQL queries, the `output` should be the _result_ of the SQL query generated by the model, not the query itself, because there may be multiple valid queries that answer a single question.
+     * @param event.expected: The ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to determine if your `output` value is correct or not. Braintrust currently does not compare `output` to `expected` for you, since there are so many different ways to do that correctly. Instead, these values are just used to help you navigate your experiments while digging into analyses. However, we may later use these values to re-score outputs or fine-tune your models.
+     * @param event.scores: A dictionary of numeric values (between 0 and 1) to log. The scores should give you a variety of signals that help you determine how accurate the outputs are compared to what you expect and diagnose failures. For example, a summarization app might have one score that tells you how accurate the summary is, and another that measures the word similarity between the generated and grouth truth summary. The word similarity score could help you determine whether the summarization was covering similar concepts or not. You can use these scores to help you sort, filter, and compare experiments.
+     * @param event.metadata: (Optional) a dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings.
+     * @param event.metrics: (Optional) a dictionary of metrics to log. The following keys are populated automatically and should not be specified: "start", "end", "caller_functionname", "caller_filename", "caller_lineno".
+     * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
+     * @param event.dataset_record_id: (Optional) the id of the dataset record that this event is associated with. This field is required if and only if the experiment is associated with a dataset.
+     * @param event.inputs: (Deprecated) the same as `input` (will be removed in a future version).
+     * :returns: The `id` of the logged event.
      */
-    log({ input, output, expected, scores, metadata, id, datasetRecordId, inputs, }: {
-        readonly input?: unknown;
-        readonly output: unknown;
-        readonly expected?: unknown;
-        readonly scores: Record<string, number>;
-        readonly metadata?: Record<string, unknown>;
-        readonly id?: string;
-        readonly datasetRecordId?: string;
-        readonly inputs?: unknown;
-    }): string;
+    log(event: Readonly<ExperimentLogFullArgs>): string;
+    /**
+     * Create a new toplevel span. The name parameter is optional and defaults to "root".
+     *
+     * See `Span.startSpan` for full details.
+     */
+    startSpan(args?: StartSpanOptionalNameArgs): Span;
+    /**
+     * Wrapper over `Experiment.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.traced` for full details.
+     */
+    traced<R>(callback: (span: Span) => R, args?: StartSpanOptionalNameArgs & SetCurrentArg): R;
     /**
      * Summarize the experiment, including the scores (compared to the closest reference experiment) and metadata.
      *
@@ -207,6 +393,50 @@ export declare class Experiment {
         readonly summarizeScores?: boolean;
         readonly comparisonExperimentId?: string;
     }): Promise<ExperimentSummary>;
+    /**
+     * Finish the experiment and return its id. After calling close, you may not invoke any further methods on the experiment object.
+     *
+     * Will be invoked automatically if the experiment is wrapped in a callback passed to `braintrust.withExperiment`.
+     *
+     * @returns The experiment id.
+     */
+    close(): Promise<string>;
+    private checkNotFinished;
+}
+/**
+ * Primary implementation of the `Span` interface. See the `Span` interface for full details on each method.
+ *
+ * We suggest using one of the various `startSpan` methods, instead of creating Spans directly. See `Span.startSpan` for full details.
+ */
+export declare class SpanImpl implements Span {
+    private finished;
+    private experimentLogger;
+    private internalData;
+    private isMerge;
+    id: string;
+    span_id: string;
+    root_span_id: string;
+    private _project_id;
+    private _experiment_id;
+    kind: "span";
+    constructor(args: {
+        experimentLogger: LogThread;
+        name: string;
+        spanAttributes?: Record<any, any>;
+        startTime?: number;
+        setCurrent?: boolean;
+        event?: ExperimentLogPartialArgs & Partial<IdField>;
+    } & ({
+        rootExperiment: Experiment;
+    } | {
+        parentSpan: SpanImpl;
+    }));
+    log(event: ExperimentLogPartialArgs): void;
+    startSpan(name: string, args?: StartSpanArgs): Span;
+    traced<R>(name: string, callback: (span: Span) => R, args?: StartSpanArgs & SetCurrentArg): R;
+    end(args?: EndSpanArgs): number;
+    close(args?: EndSpanArgs): number;
+    private checkNotFinished;
 }
 /**
  * A dataset is a collection of records, such as model inputs and outputs, which represent
@@ -223,6 +453,7 @@ export declare class Dataset {
     private pinnedVersion?;
     private _fetchedData?;
     private logger;
+    private finished;
     constructor(project: Project, id: string, name: string, user_id: string, pinnedVersion?: string);
     /**
      * Insert a single record to the dataset. The record will be batched and uploaded behind the scenes. If you pass in an `id`,
@@ -288,6 +519,15 @@ export declare class Dataset {
     fetchedData(): Promise<any[]>;
     clearCache(): void;
     version(): Promise<any>;
+    /**
+     * Terminate connection to the dataset and return its id. After calling close, you may not invoke any further methods on the dataset object.
+     *
+     * Will be invoked automatically if the dataset is bound as a context manager.
+     *
+     * @returns The dataset id.
+     */
+    close(): Promise<string>;
+    private checkNotFinished;
 }
 /**
  * Summary of a score's performance.
@@ -347,3 +587,4 @@ export interface DatasetSummary {
     datasetUrl: string;
     dataSummary: DataSummary;
 }
+export {};

package/dist/merge_row_batch.d.ts

@@ -0,0 +1 @@
+export declare function mergeRowBatch(rows: Record<string, any>[]): Record<string, any>[];

package/dist/stackutil.d.ts

@@ -0,0 +1,8 @@
+import { CallerLocation } from "./isomorph";
+export interface StackTraceEntry {
+    functionName: string;
+    fileName: string;
+    lineNo: number;
+}
+export declare function getStackTrace(): StackTraceEntry[];
+export declare function getCallerLocation(): CallerLocation | undefined;